黑马全套Java教程（二）

文章目录

• ​​9 IDEA下载、安装与概述、使用​​

• ​​9.1 IDEA的下载​​
• ​​9.2 安装​​
• ​​9.3 IDEA的基本使用​​
• ​​9.4 IDEA字体修改​​
• ​​9.5 IDEA中内容辅助键和快捷键​​
• ​​9.6 IDEA中模块操作​​
• ​​9.7 导入模块​​

• ​​10 数组​​

• ​​10.1 数组定义格式​​
• ​​10.2 数组动态初始化​​
• ​​10.3 数组元素访问​​
• ​​10.4 内存分配​​
• ​​10.5 数组静态初始化​​
• ​​10.6 数组操作常见问题​​
• ​​10.7 数组常见操作​​

• ​​11 方法​​

• ​​11.1 方法概述​​
• ​​11.2 方法的定义和调用​​
• ​​11.3 带参数方法定义与调用​​
• ​​11.4 形参与实参​​
• ​​11.5 带返回值的方法定义与调用​​
• ​​11.6 方法的注意事项​​
• ​​11.7 方法的通用格式​​
• ​​11.8 方法重载​​
• ​​11.9 方法的参数传递​​

• ​​12 Debug​​

• ​​12.1 Debug操作流程​​

• ​​13 已学内容案例练习​​

本博客配套黑马的教学视频，B战可以搜索到，​​教学视频链接​​，从第53个视频IDEA的安装开始，前52个视频的配套CSDN请查看我的另外一篇博客，​​博客链接​​

9 IDEA下载、安装与概述、使用

IDEA全称InteliJ IDEA，是用于Java语言开发的集成环境，它是业界公认的目前用于Java程序开发最好的工具

集成环境：把代码编写、编译、执行、调试等多种功能综合到一起的开发工具

9.1 IDEA的下载

官网链接：​​https://www.jetbrains.com/idea/​​

9.2 安装

安装教程：​​javascript:void(0)​​

9.3 IDEA的基本使用

由于本人是先看了很多视频，再回来补的博客，所以这里的项目->模块->包->类的创建流程这里就不做详细的教程啦
IDEA的基本使用可以查看黑马的第54个视频，​​​视频链接​​

这张图中，idea_test是模块，在src下，com.itheima为包，ArrayDemo为类IDEA项目结构如下：

9.4 IDEA字体修改

File->Settings->Editor->Font

9.5 IDEA中内容辅助键和快捷键

快速生成语句

• 快速生成main()方法：​​psvm + 回车​​
• 快速生成输出语句：​​sout + 回车​​

内容辅助键
Ctrl+Alt+space：内容提示，代码补全等

快捷键
单行注释：选中代码，Ctrl+/，再来一次就是取消注释
多行注释：选中代码，Ctrl+Shift+/，再来一次就是取消注释

格式化代码
Ctrl+Alt+L

9.6 IDEA中模块操作

新建模块：

File->Project Structure->Modules->±>New Module

删除模块：

右键模块->remove module

上面只是在工作区间上移除了，而硬盘上还是存在的，还需到对应的文件夹中去删除对应模块文件

快速定位到模块所在目录
右键模块名->open in ->explorer

9.7 导入模块

File->Project Structure->Modules-> + ->import Module ->找到需要导入的模块名称

10 数组

10.1 数组定义格式

数组的定义格式有两种：
格式一：​​​数据类型[] 变量名​​​ 范例：​​int[] arr​​ 定义了一个int类型的数组，数组名是arr

格式二：​​数据类型 变量名[]​​​ 范例：​​int arr[]​​ 定义了一个int类型的变量，变量是arr数组
推荐使用格式一

例：注意，定义数组会默认给数组赋初始值，值为0

package com.itheima;

public class ArrayTest4 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

10.2 数组动态初始化

Java中的数组必须先初始化，然后才能使用
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值

数组初始化有两种方法：动态初始化、静态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
格式：​​​数据类型[] 变量名 = new 数据类型[数组长度];​​​ 范例：​​int[] arr = new int[3];​​

10.3 数组元素访问

数组变量访问方式
格式：数组名

数组内部保存的数据的访问方式
格式：​​​数组名[索引]​​

索引是数组中数据的编号方式
作用：索引用于访问数组中的数据使用，**数组名[索引]**等同于变量名，是一种特殊的变量名
特征1：索引是从0开始的
特征2：索引是连续的
特征3：索引是逐一增加的，每次加1

package com.itheima;
/*
    数组：是一种用于存储多个相同类型数据的存储模型

    定义格式：（推荐方式）
        数据类型[] 数组名;
        举例： int[] arr;

    数组初始化：
        动态初始化
            int[] arr = new int[3];
        静态初始化
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //int[]  int类型数组
        //arr   数组名称
        //new   为数组申请内存空间
        //int[3]   数组，元素类型为整型，3个元素
        int[] arr = new int[3];

        //赋值
        arr[0] = 100;
        arr[2] = 200;

        //输出数组名
        System.out.println(arr);   //[I@58ceff1

        //输出数组中的元素
        System.out.println(arr[0]);    //0是由系统分配的
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

10.4 内存分配

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

单个数组内存图如下

代码实现如下

package com.itheima;

public class ArrayTest1 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = new int[3];

        //输出数组名及元素
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("赋值后----------");
        //给数组中元素赋值
        arr[0] = 100;
        arr[1] = 200;

        //再次输出
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

多个数组的内存图如下

代码实现如下

package com.itheima;

public class ArrayTest2 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = new int[3];
        int[] arr2 = new int[3];

        //输出数组名及元素
        System.out.println("arr----");
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("arr2-------");
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

        System.out.println("赋值后----------");
        //给数组中元素赋值
        arr[0] = 100;
        arr2[0] = 200;
        arr2[2] = 300;

        //再次输出
        System.out.println("arr----");
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("arr2-------");
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

多个数组指向相同时

代码实现如下

package com.itheima;

public class ArrayTest3 {
    //多个数组指向相同时
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = new int[3];
        arr[0] = 100;
        arr[1] = 200;
        arr[2] = 300;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        //定义第二个数组，并指向第一个数组
        int[] arr2 = arr;
        arr2[0] = 111;
        arr2[1] = 222;
        arr2[2] = 333;
        System.out.println("arr---------");
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println("arr2---------");
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

    }
}

10.5 数组静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统确定数组长度
格式：​​​数组类型[] 变量名 = new 数据类型[] {数据1，数据2，数据3，...};​​​ 范例：​​int[] arr = new int[] {1,2,3};​​ 简化格式：​​数据类型[] 变量名 = {数据1，数据2，数据3，...}​​ 范例：​​int[] arr = {1,2,3};​​ 推荐简化格式

package com.itheima;

/*
    静态初始化
 */

public class ArrayDemo02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr1 = new int[] {1,2,3};  //一样可以
        int[] arr = {1,2,3};

        //输出数组名
        System.out.println(arr);

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

10.6 数组操作常见问题

1.索引越界：访问了数组中不存在的索引对应的元素

代码演示如下

package com.itheima;
/*
    索引越界：访问的元素超出索引
 */
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

2.空指针异常：访问的数组已经不再指向堆内存的数据

null是空值，引用数据类型的默认值，表示不指向任何有效对象

代码演示如下

package com.itheima;
/*
    空指针异常
    null：空值
 */
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //空指针异常
        //null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

10.7 数组常见操作

1.遍历

package com.itheima;
/*
    遍历：获取数组中的每一个元素，并输出

    获取数组长度：arr.length
 */

public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11,22,33,44,55};

        //遍历
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
}

2.获取最值

package com.itheima;
/*
    获取最值
 */
public class ArrayTest02 {
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        int max = arr[0];
        int min = arr[0];
        for (int i=1; i<arr.length; i++){
            if (max < arr[i]){
                    max = arr[i];
            }
            if(min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
    }
}

11 方法

11.1 方法概述

什么是方法？
方法是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

注意事项：

1. 方法必须先创建才可以使用，该过程称为方法定义
2. 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用
   

11.2 方法的定义和调用

方法的定义：

方法的调用：

代码例子如下：

package myMethod;
/*
    方法：就是函数
    定义格式：
        public static void 方法名()
        {
            方法体
        }

    调用格式：
        方法名();
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        isEvenNumber();
    }

    //需求：定义一个方法，在方法中定义一个变量，判断该数据是否为偶数
    public static void isEvenNumber(){
        //定义变量
        int number = 20;
        //判断是否为偶数
        if (number%2==0){
            System.out.println(true);
        }
        else{
            System.out.println(false);
        }
    }
}

注意：先定义后调用，否则程序报错

具体调用流程图如下：

案例1：打印两个数中的最大值

package myMethod;
/*
    判断并输出两个数的最大值
 */
public class MethodDemo02 {
    public static void main(String[] args) {
        getMax();
    }
    public static void getMax(){
        int a = 10;
        int b = 20;
        if (a>b){
            System.out.println(a);
        }
        else{
            System.out.println(b);
        }
    }
}

11.3 带参数方法定义与调用

定义

调用

package myMethod;
/*
    带参数方法的定义和调用

    定义格式：
        public static void 方法名(参数){}

    调用格式：
        方法名(参数);
 */


public class MethodDemo03 {
    public static void main(String[] args) {
        isEvenNumber(19);
    }
    public static void isEvenNumber(int number){
        if(number%2==0){
            System.out.println(true);
        }
        else{
            System.out.println(false);
        }
    }
}

11.4 形参与实参

形参：方法定义中的参数，等同于变量定义格式，例如：int number

实参：方法调用中的参数，等同于使用变量或常量，例如：10， number

例：

package myMethod;
/*
    参数个数对应
 */
public class MethodDemo04 {
    public static void main(String[] args) {
        getMax(10,20);
    }
    public static void getMax(int a, int b){
        if (a>b){
            System.out.println(a);
        }
        else{
            System.out.println(b);
        }
    }
}

11.5 带返回值的方法定义与调用

定义

调用

package myMethod;
/*
    带返回值方法的定义和调用

    定义格式：
        public static 数据类型 方法名(参数){
            return 数据;
        }

    调用格式：
        1.方法名(参数)；
        2.数据类型 变量名 = 方法名(参数);
 */


public class MethodDemo05 {
    public static void main(String[] args) {
        boolean target = isEvenNumber(20);
        System.out.println(target);
    }
    //需求：定义一个方法，该方法接收一个参数，判断该数据是否为偶数，并返回真假值
    public static boolean isEvenNumber(int number){
        if(number%2==0){
            return true;
        }
        else{
            return false;
        }
    }
}

案例：

package myMethod;

/*
    需求：
        设计一个方法可以获取两个数的较大值，数据来自于参数
 */

public class MethodDemo06 {
    public static void main(String[] args) {
        int max = getMax(10,20);
        //两种输出方法
        System.out.println(max);
        System.out.println(getMax(10,20));
    }
    //定义一个方法，用于获取两个数字的较大数
    public static int getMax(int a, int b){
        if (a>b){
            return a;
        }
        else{
            return b;
        }
    }
}

11.6 方法的注意事项

1.方法不能嵌套定义

2.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

package myMethod;

public class MethodDemo07 {
    public static void main(String[] args) {

    }
    public static void methodOne(){

    }   //可以省略return，或者只写return不返回数
    public static void methodTwo(){
        return;
    }
}

11.7 方法的通用格式

11.8 方法重载

方法重载：指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法可以构成重载

1. 多个方法在同一个类中
2. 多个方法具有相同的方法名
3. 多个方法的参数不相同，参数类型不同或者参数数量不同

重载仅对应方法的定义，与方法的调用无关，调用方法参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否构成重载

代码实现如下：

package myMethod;

/*
    方法重载：
        多个方法在同一个类中
        多个方法具有相同的方法名
        多个方法的参数不相同，类型不同或者数量不同

        与返回值无关
        在调用的时候Java虚拟机会根据参数的不同调用相同名字的不同方法
 */

public class MethodDemo08 {
    public static void main(String[] args) {
        int result = sum(1,2);
        System.out.println(result);

        double result1 = sum(1.1, 2.1);
        System.out.println(result1);

        int result2 = sum(1,2,3);
        System.out.println(result2);
    }
    //需求1：求两个int类型数据和的方法
    public static int sum(int a, int b){
        return a+b;
    }

    //需求2：求连那个歌double类型数据和的方法
    public static double sum(double a, double b){
        return a+b;
    }

    //需求3：求三个int类型数据和的方法
    public static int sum(int a, int b, int c){
        return a+b+c;
    }
}

练习：判断两个数是否相等

package myMethod;

public class MethodDemo09 {
    public static void main(String[] args) {
        System.out.println(compare(1,2));
        System.out.println(compare((short)1,(short)2));  //强转
        System.out.println(compare(1L,2L));
        System.out.println(compare((byte)1,(byte)2));
    }

    //int
    public static boolean compare(int a, int b){
        System.out.println("int");
        return a==b;
    }

    //long
    public static boolean compare(long a, long b){
        System.out.println("long");
        return a==b;
    }

    //short
    public static boolean compare(short a, short b){
        System.out.println("short");
        return a==b;
    }

    //byte
    public static boolean compare(byte a, byte b){
        System.out.println("byte");
        return a==b;
    }
}

11.9 方法的参数传递

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值

package myMethod;

/*
    对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
 */

public class ArgsDemo01 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);
        change(number);
        System.out.println("调用change方法后：" + number);

        System.out.println("----------------------------");
        System.out.println("调用change1方法前：" + number);
        number = change1(number);
        System.out.println("调用change1方法后：" + number);
    }
    public static void change(int number){
        number = 200;
    }
    public static int change1(int number){
        number = 200;
        return number;
    }
}

对于引用类型的参数，形式参数的改变，影响实际参数的值
例2：代码实现如下

package myMethod;
/*
    对于引用类型的参数，形式参数的改变，影响实际参数的值
 */
public class ArgsDemo02 {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        System.out.println("调用change方法前：" + arr[1]);
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }
    public static void change(int[] arr){
        arr[1] = 200;
    }
}

案例1：数组遍历

package myMethod;
/*
    数组遍历，在一行输出
 */
public class MethodTest01 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        printArray(arr);
    }

    public static void printArray(int[] arr){
        System.out.print('[');
        for (int i=0; i<arr.length; i++){
            System.out.print(arr[i]);
            if (i != arr.length-1){
                System.out.print(',');
            }
        }
        System.out.print(']');
    }
}

案例2：输出最大值

package myMethod;
/*
    获取数组中最大值：
        1.调用方法
        2.在控制台输出
 */
public class MethodTest02 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,55,44,10};
        System.out.println(max(arr));
    }

    public static int max(int[] arr){
        int max = arr[0];
        for(int i=0; i< arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
}

12 Debug

本章节对应黑马的第86个视频，​​视频链接​​

12.1 Debug操作流程

Debug：是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。
Debug调试：又称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看

Debug调试内容如下：

1. 如何加断点
2. 如何运行加了断点的程序
3. 看哪里
4. 点哪里
5. 如何删除断点

具体操作使用流程看视频比看博客更容易理解，请查看本章节上面的视频链接，本章节使用到的代码如下：

package Debug;
/*
    1.如何加断点
    2.如何运行加了断点的程序
    3.看哪里
    4.点哪里
    5.如何删除断点
 */
public class DebugDemo {
    public static void main(String[] args) {
        //定义两个变量
        int i = 10;
        int j = 20;

        //求和
        int sum = i + j;

        //输出结果
        System.out.println("sum:" + sum);
    }
}

例2：视频87的代码

package Debug;

/*
    查看循环求偶数和的执行流程
 */
public class DebugTest01 {
    public static void main(String[] args) {
        //定义求和变量
        int sum = 0;

        //循环求偶数和
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }

        //输出结果
        System.out.println(sum);
    }
}

13 已学内容案例练习

首先介绍一下导包的三种方法：
1.手动导包
2.Alt+Enter
3.自动导包，回车导包

案例1：减肥计划

package myTest;
/*
    需求：输入星期数，输出今天的减肥活动
        周一：跑步
        周二；游泳
        周三：慢走
        周四：动感单车
        周五：拳击
        周六：爬山
        周日：好好吃一顿

*/

//1.导包
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        //调用方法
        int week = Input();
        while(week<1 || week>7)
        {
            System.out.println("你输入的星期数有误！请重新输入！");
            week = Input();
        }

        if (week==1)
        {
            System.out.println("跑步");
        }
        else if (week==2)
        {
            System.out.println("游泳");
        }
        else if (week==3)
        {
            System.out.println("慢走");
        }
        else if (week==4)
        {
            System.out.println("动感单车");
        }
        else if (week==5)
        {
            System.out.println("拳击");
        }
        else if (week==6)
        {
            System.out.println("爬山");
        }
        else if (week==7)
        {
            System.out.println("好好吃一顿");
        }
    }
    public static int Input()
    {
        //2.创建对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入星期：");
        //3.接收数据
        int week = sc.nextInt();
        return week;
    }
}

案例2：Switch实现上面功能

package myTest;
/*
    需求：输入星期数，输出今天的减肥活动
        周一：跑步
        周二；游泳
        周三：慢走
        周四：动感单车
        周五：拳击
        周六：爬山
        周日：好好吃一顿

*/

//1.导包
import java.util.Scanner;
public class Test02 {
    public static void main(String[] args) {
        //调用方法
        int week = Input();
        while(week<1 || week>7)
        {
            System.out.println("你输入的星期数有误！请重新输入！");
            week = Input();
        }

        switch(week)
        {
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            //default:
        }
    }
    public static int Input()
    {
        //2.创建对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入星期：");
        //3.接收数据
        int week = sc.nextInt();
        return week;
    }
}

案例3：逢7过

package myTest;
/*
    逢7过
    个位是7，或者十位是7，或者被7整除，就输出过
 */
public class Test03 {
    public static void main(String[] args) {
        for(int x=1; x<=100; x++)
        {
            if(x%10==7 || x/10%10==7 || x/7==0)
            {
                System.out.println("过");
            }
            else
            {
                System.out.println(x);
            }
        }
    }
}

案例4：不是神兔（递归）

package myTest;
/*
    需求：
        有一对兔子，三个月起每个月生一对兔子
        20个月后有多少对
 */
public class Test04 {
    public static void main(String[] args) {
        int[] arr = new int[20];
        arr[0] = arr[1] = 1;
        for(int i=2; i<20; i++){
            arr[i] = arr[i-1] + arr[i-2];
        }
        System.out.println(arr[19]);
        System.out.println("-------------------");
        System.out.println(Add(arr, 19));
    }
    public static int Add(int[] arr, int i){
        arr[0] = arr[1] = 1;
        arr[i] = arr[i-1] + arr[i-2];
        return arr[i];
    }
}

案例5：百钱白鸡

package myTest;

/*
    百钱白鸡
 */
public class Test05 {
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            for (int y = 0; y <= 33; y++) {
                int z = 100 - x - y;
                if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
                    System.out.println("x:" + x);
                    System.out.println("y:" + y);
                    System.out.println("z:" + z);
                    System.out.println("--------------------");
                }
            }
        }
    }
}

案例6：数组元素求和
求和的元素个位和十位不能是7，且只能是偶数

package myTest;

public class Test06 {
    public static void main(String[] args) {
        int[] arr = {68,27,95,88,171,996,51,210};
        int sum = 0;
        for (int i=0; i<arr.length; i++){
            if(arr[i]%2==0 && arr[i]%10!=7 && arr[i]/10%10!=7){
                sum += arr[i];
            }
        }
        System.out.println(sum);
    }
}

案例7：数组内容相同比较

package myTest;
/*
    比较两个数组是否相同
 */
public class Test07 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        int[] arr1 = {11,22,33,44,55};
        System.out.println(compare(arr,arr1));
    }

    public static boolean compare(int[] arr, int[] arr1) {
        if (arr.length != arr1.length) {
            return false;
        }

        for (int x=0; x< arr.length; x++){
            if(arr[x] != arr1[x]){
                return false;
            }
        }
        return true;
    }
}

案例8：查找索引值

package myTest;
import java.util.Scanner;
public class Test08 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {19,28,37,46,50};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int number = sc.nextInt();

        int index = getIndex(arr, number);

        //输出索引变量
        System.out.println(index);
    }
    public static int getIndex(int[] arr, int number){
        //定义索引
        int index = -1;
        //遍历数组
        for (int x=0; x< arr.length; x++){
            if(arr[x] == number){
                index = x;
                break;
            }
        }
        return index;
    }
}

案例9：反转

package myTest;

public class Test09 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};
        reverse(arr);

        //遍历输出数组
        printArray(arr);
    }

    //反转
    public static void reverse(int[] arr){
        //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }

    //遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ",");
            }
        }
        System.out.print("]");
    }
}

案例10：评委打分
去掉最高分最低分，求平均值

package myTest;

import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];

        //键盘录入评委分数
        Scanner sc = new Scanner(System.in);

        for(int x=0; x<arr.length; x++){
            System.out.println("请输入第" + (x+1) + "个评委的打分：");
            arr[x] = sc.nextInt();
        }
        printArray(arr);
        int max = getMax(arr);
        int min = getMin(arr);
        int sum = getSum(arr);
        int avg = (sum-max-min)/(arr.length-2);
        System.out.println("avg:" + avg);
    }

    //遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ",");
            }
        }
        System.out.println("]");
    }

    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i=0; i<arr.length; i++){
            if(max<arr[i]){
                max = arr[i];
            }
        }
        return max;
    }

    public static int getMin(int[] arr){
        int min = arr[0];
        for (int i=0; i<arr.length; i++){
            if(min>arr[i]){
                min = arr[i];
            }
        }
        return min;
    }

    public static int getSum(int[] arr){
        int sum = 0;
        for (int i=0; i< arr.length; i++){
            sum += arr[i];
        }
        return sum;
    }
}