第3章、数组

一、数组的概述

1、数组的理解

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2、数组的常见概念

• 数组名
• 下标(或索引)
• 元素
• 数组的长度

3、数组的特点

• 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
• 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
• 数组的长度一旦确定，就不能修改。
• 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。

4、数组的分类

• 按照维度：一维数组、二维数组、三维数组、…
• 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

二、一维数组的使用

1、声明方式

type var[] 或 type[] var；

示例

int num;     //声明
num = 10;    //初始化
int a = 100; //声明 + 初始化

int[] ids; //数组的声明
//        int ids[]; 这样也可以 但是不推荐

2、初始化

（1）静态初始化

数组的初始化和数组元素的赋值操作同时进行

int[] ids; //数组的声明
//1.1 静态初始化: 数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001, 1002, 1003};

int[] arr1 = new int[]{1, 2, 3};
int[] arr2 = {1, 2, 3};//类型推断，只有声明和

//分两行就推断不出来 编译不通过
// int[] arr3;
//arr3 = {1, 2 ,3};

（2）动态初始化

数组的初始化和数组元素的赋值操作分开进行

//1.2 动态初始化: 数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];

3、数组元素的引用

• 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
• 数组元素的引用方式：数组名[数组元素下标]
  • 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
  • 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
• 每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
  • 数组一旦初始化，其长度是不可变的

 //总结：数组一旦初始化完成，其长度就确定了

//(2)如何调用数组指定位置的元素：通过索引的方式调用
//数组的索引是从0开始的，到数组的长度-1结束
names[0] = "张三";
names[1] = "李四";
names[2] = "王五";
names[3] = "赵六";
names[4] = "孙七";

//3、如何获取数组的长度
//属性 length
System.out.println(ids.length);
System.out.println(names.length);

//4、如何遍历数组
for (int i = 0; i < ids.length; i++){
    System.out.println(ids[i]);
}

for (int i = 0; i < names.length; i++){
    System.out.println(names[i]);
}

4、数组元素的默认初始化值

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。

对于基本数据类型而言，默认初始化值各有不同

对于引用数据类型而言，默认初始化值为null(注意与0不同！)

例如：

//数组元素是整型
int[] arr = new int[4];
for (int i = 0; i < arr.length; i++){
    System.out.println(arr[i]);
}

System.out.println();

short[] arr1 = new short[4];
for (int i = 0; i < arr1.length; i++){
    System.out.println(arr1[i]);
}

System.out.println();

//数组元素是浮点型
float[] arr2 = new float[4];
for (int i = 0; i < arr2.length; i++){
    System.out.println(arr2[i]);
}

System.out.println();

//数组元素是字符型
char[] arr3 = new char[4];
for (int i = 0; i < arr3.length; i++){
    System.out.println(arr3[i]);
}

System.out.println();

//数组元素是布尔型
boolean[] arr4 = new boolean[4];
for (int i = 0; i < arr4.length; i++){
    System.out.println(arr4[i]);
}

System.out.println();
//数组元素是引用数据类型：String
String[] arr45 = new String[4];
for (int i = 0; i < arr45.length; i++){
    System.out.println(arr45[i]);
}

5、内存结构的简单说明

6、一维数组的内存解析

int[] arr = new int[]{1,2,3};
String[] arr1 = new String[4];
arr1[1] = “刘德华”;
arr1[2] = “张学友”;
arr1 = new String[3];
sysout(arr1[1]);//null

7、一维数组的练习

练习一

/**
 * @author: huxingxin
 * @date: 2022/11/23 15:38:43
 * @description:
 */
public class Test1 {
    public static void main(String[] args) {
        /*
        升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。
        屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。
         */
        int[] arr = new int[]{8, 2, 1, 0, 3};
        int[] index = new int[]{2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};
        String tel = "";
        for (int i = 0; i < index.length; i++) {
            tel += arr[index[i]];
        }
        System.out.println("联系方式：" + tel);//18013820100
    }
}

练习二

import java.util.Scanner;

/**
 * @author: huxingxin
 * @date: 2022/11/23 15:38:43
 * @description:
 */
public class Test2 {
    public static void main(String[] args) {
       /*
       2. 从键盘读入学生成绩，找出最高分，
        并输出学生成绩等级。
        成绩>=最高分-10 等级为’A’
        成绩>=最高分-20 等级为’B’
        成绩>=最高分-30 等级为’C’
        其余 等级为’D’

        提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
        */


        //1、创建scanner 读取学生个人
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入学生人数: ");
        int studentNum = scanner.nextInt();

        //2、创建int数组，存放学生成绩。
        int[] scores = new int[studentNum];
        int maxScore = 0;//最高分

        //3、给数组中的元素赋值
        for (int i = 0; i < scores.length; i++){
            System.out.print("请输入学生 " + (i + 1) + " 的成绩: ");
            scores[i] = scanner.nextInt();
            //4、获取数组中的最大元素，找出最高分
            if (maxScore < scores[i]){
                maxScore = scores[i];
            }
        }

        System.out.println();
        System.out.println("最高分是：" + maxScore);

        //4、根据每个学生与最高分的差值，得到每个学生的等级，并输出成绩和等级
        char level;
        for (int i = 0; i < scores.length; i++){
            if (scores[i] >= maxScore - 10){
                level = 'A';
            }else if (scores[i] >= maxScore - 20){
                level = 'B';
            }else if (scores[i] >= maxScore - 30){
                level = 'C';
            }else {
                level = 'D';
            }
            System.out.println("学生 " + (i + 1) + " 分数为 " + scores[i] + ", 等级为 " + level);
        }
    }
}

三、多维数组的使用

1、二维数组的理解

Java 语言里提供了支持多维数组的语法

如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格，像右图Excel中的表格一样。

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

二维数组：数组中的数组。

2、二维数组的声明方式

int[][] arr;
//这样也是正确的 但是不推荐
// int arr4[][];
// int[] arr4[];

3、二维数组的初始化

（1）格式1（动态初始化）：

int[][] arr = new int[3][2];

• 定义了名称为arr的二维数组
• 二维数组中有3个一维数组
• 每一个一维数组中有2个元素
• 一维数组的名称分别为arr[0], arr[1], arr[2]
• 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

（2）格式2（动态初始化）：

int[][] arr = new int[3][];

• 二维数组中有3个一维数组。
• 每个一维数组都是默认初始化值null (注意：区别于格式1）
• 可以对这个三个一维数组分别进行初始化
• arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
• 注：
  int[][]arr = new int[][3]; //非法

（3）格式3（静态初始化）：

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

• 定义一个名称为arr的二维数组，二维数组中有三个一维数组
• 每一个一维数组中具体元素也都已初始化
• 第一个一维数组 arr[0] = {3,8,2};
• 第二个一维数组 arr[1] = {2,7};
• 第三个一维数组 arr[2] = {9,0,1,6};
• 第三个一维数组的长度表示方式：arr[2].length;
• 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
• Java中多维数组不必都是规则矩阵形式

//静态初始化
int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8}};
//动态初始化1
int[][] arr2 = new int[3][2];
//动态初始化2
int[][] arr3 = new int[3][];

//这样也是正确的 但是不推荐
//        int arr4[][];
//        int[] arr4[];

//2、如何调用数组指定位置的元素
System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//0

arr3[1] = new int[2];
System.out.println(arr3[1][1]);//0

//3、获取数组的长度
System.out.println(arr1.length);//3
System.out.println(arr1[0].length);//3
System.out.println(arr1[1].length);//3

//4、如何遍历二维数组
for(int i = 0; i < arr1.length; i++){
    for (int j = 0; j < arr1[i].length; j++){
        System.out.print(arr1[i][j] + " ");
    }
    System.out.println();
}

4、数组元素的默认初始值

//5、数组元素的默认初始化值
//int类型
int[][] arr = new int[3][];
System.out.println(arr[0]);// null
// System.out.println(arr[0][0]); //NullPointerException
System.out.println(arr); //[[I@1b6d3586

int[][] arr1 = new int[3][4];
System.out.println(arr1[0]);// [I@1b6d3586 地址值
System.out.println(arr1[0][0]); //0
System.out.println(arr1); //[[I@74a14482

//float类型
float[][] arr3 = new float[3][4];
System.out.println(arr3[0]);// [F@1540e19d 地址值
System.out.println(arr3[0][0]); //0.0

//String类型
String[][] arr4 = new String[3][4];
System.out.println(arr4[0]);// [Ljava.lang.String;@677327b6 地址值
System.out.println(arr4[0][0]); //null

5、二维数组的内存解析

int[][] arr1 = new int[4][];
arr1[1] = new int[]{1,2,3};
arr1[2] = new int[4];
arr1[2][1] = 30;

6、二维数组的练习

练习1

/**
 * @author: huxingxin
 * @date: 2022/11/24 20:47:00
 * @description:
 */
public class Test1 {
    public static void main(String[] args) {
        //1、练习1 计算数组中所有元素的和
        int[][] arr = {{3, 5, 8}, {12, 9}, {7, 0, 6, 4}};

        int sum = 0;//记录总和
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        System.out.println("sum: " + sum);

    }
}

练习2

/**
 * @author: huxingxin
 * @date: 2022/11/24 20:47:00
 * @description:
 */
public class Test2 {
    public static void main(String[] args) {
        /*
        2、使用二维数组打印一个 10 行杨辉三角
        【提示】
        1. 第一行有 1 个元素, 第 n 行有 n 个元素
        2. 每一行的第一个元素和最后一个元素都是 1
        3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
        yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
         */

//        int[][] arr1 = new int[10][];//用于记录 10 行杨辉三角 每一行的数据
//        for (int i = 1; i <= 10; i++){
//            arr1[i-1] = new int[i]; //记录当前行的数据
//            for (int j = 1; j <= i; j++){
//                if (j == 1 || j == i) { //第一行和最后以后都输出1
//                    arr1[i-1][j-1] = 1;
//                    System.out.print(1 + " ");
//                }else if (i > 2){  //从第三行 第二个数开始
//                    arr1[i-1][j-1] = arr1[i-2][j-2] + arr1[i-2][j-1];
//                    System.out.print(arr1[i-1][j-1] + " ");
//                }
//            }
//            System.out.println();
//        }

        System.out.println();
        //声明初始化二维数组 用于记录 10 行杨辉三角 每一行的数据
        int[][] arr1 = new int[10][];
        //给数组的元素赋值
        for (int i = 0; i < 10; i++){
            arr1[i] = new int[i+1];// 记录当前行的数据
            arr1[i][0] = arr1[i][i] = 1; //首末元素赋值

            //非首末元素赋值
            for (int j = 1; j < arr1[i].length -1; j++){
                arr1[i][j] = arr1[i-1][j-1] + arr1[i-1][j];
            }

        }

        for (int i = 0; i < arr1.length; i++){
            for (int j = 0; j < arr1[i].length; j++){
                System.out.print(arr1[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println();
        
        
        //3、创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。
        int[] arr3 = new int[30];
        boolean flag;
        for (int i = 0; i < arr3.length; i++){
            flag = true;
            while (flag){
                int random = (int)(Math.random() * 30 + 1);//0~30之间的数字
                int index = 0;
                for (int j = 0; j < i; j++){//将随机数与前面的所有元素进行比对
                    if (random == arr3[j]){ //如果相同，重新生成随机数，进行比对
                        break;
                    }
                    index++;
                }
                if (index == i){//当比对完毕都没有相同的元素，则放入数组，开始下一轮
                    arr3[i] = random;
                    flag = false;
                }
            }
        }

        for (int i = 0; i < arr3.length; i++){
            System.out.print(arr3[i] + " ");
        }



    }
}

练习3

import java.util.Random;

/**
 * @author: huxingxin
 * @date: 2022/11/25 9:23:24
 * @description:
 */
public class Test3 {
    public static void main(String[] args) {
        //输入几 就打印几行几列 如：
        /*
        1 2 3
        4 5 6
        7 8 9
         */
        int num = 3;
        for (int i = 1; i <= num; i++){
            for (int j = num * i - num + 1; j < num * i + 1; j++){
                System.out.print(j + " ");
            }
            System.out.println();
        }

        System.out.println();
        /*
        定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
        然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
        要求：所有随机数都是两位数。
         */

        int[] arr = new int[10];
        //给数组赋值
        for (int i = 0; i < arr.length; i++){
            arr[i]= (int)(Math.random() * 90 + 10);
        }

        int max;//最大值
        int min;//最小值
        int sum = 0;//和值
        double average;//平均值
        max = min = arr[0];
        for (int i = 0; i < arr.length; i++){
            //获取最大值
            if (max < arr[i]){
                max = arr[i];
            }
            //获取最小值
            if (min > arr[i]){
                min = arr[i];
            }

            sum += arr[i];
        }
        average = sum / (double)arr.length;

        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
        System.out.println("和值：" + sum);
        System.out.println("平均值：" + average);
    }
}

四、数组中涉及到的常见算法

1、常见算法的种类

• 数组元素的赋值(杨辉三角、回形数等)
• 求数值型数组中元素的最大值、最小值、平均数、总和等
• 数组的复制、反转、查找(线性查找、二分法查找)
• 数组元素的排序算法

2、二分法查找算法

//二分法查找：要求此数组必须是有序的。
int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
boolean isFlag = true;
int number = 256;
//int number = 25;
int head = 0;//首索引位置
int end = arr3.length - 1;//尾索引位置
while(head <= end){
    int middle = (head + end) / 2;
    if(arr3[middle] == number){
        System.out.println("找到指定的元素，索引为：" + middle);
        isFlag = false;
        break;
    }else if(arr3[middle] > number){
        end = middle - 1;
    }else{//arr3[middle] < number
        head = middle + 1;
    }
}
if(isFlag){
    System.out.println("未找打指定的元素");
}

3、排序算法

排序：假设含有n个记录的序列为{R1，R2，...,Rn},其相应的关键字序列为{K1，K2，...,Kn}。将这些记录重新排序为{Ri1,Ri2,...,Rin},使得相应的关键
字值满足条Ki1<=Ki2<=...<=Kin,这样的一种操作称为排序。

通常来说，排序的目的是快速查找。

（1）衡量排序算法的优劣：

1.时间复杂度：分析关键字的比较次数和记录的移动次数

2.空间复杂度：分析排序算法中需要多少辅助内存

3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

（2）排序算法分类

• 内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
• 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

（3）十大内部排序算法

• 选择排序：直接选择排序、堆排序
• 交换排序： 冒泡排序、快速排序
• 插入排序：直接插入排序、折半插入排序、Shell排序
• 归并排序
• 桶式排序
• 基数排序

（4）算法的5大特征

说明：满足确定性的算法也称为：确定性算法。现在人们也关注更广泛的概念，例如考虑各种非确定性的算法，如并行算法、概率算法等。另外，

人们也关注并不要求终止的计算描述，这种描述有时被称为过程（procedure）。

（5）冒泡排序

介绍：

冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

（6）快速排序

介绍：

• 快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见掌握快排的重要性。
• 快速排序（Quick Sort）由图灵奖获得者Tony Hoare发明，被列为20世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))。

排序思想：

• 1. 从数列中挑出一个元素，称为"基准"（pivot），
• 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
• 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
• 4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

图示

（7）各种内部排序方法性能比较

• 1.从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归并排序。
• 2.从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
• 3.从稳定性看：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排序、快速排序、 Shell排序和堆排序是不稳定排序
• 4.从待排序的记录数n的大小看，n较小时，宜采用简单排序；而n较大时宜采用改进排序。

（8）排序算法的选择

• (1)若n较小(如n≤50)，可采用直接插入或直接选择排序。当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直
• 接插入，应选直接选择排序为宜。
• (2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
• (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。

4、练习

练习1、拷贝数组

/**
 * @author: huxingxin
 * @date: 2022/11/25 10:13:24
 * @description:
 */
public class Test1 {
    public static void main(String[] args) {
        /*
        使用简单数组
        (1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
        (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
        (3)显示array1的内容。
        (4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
        (如array[0]=0,array[2]=2)。打印出array1。
        思考：array1和array2是什么关系？
        拓展：修改题目，实现array2对array1数组的复制
         */

        int[] array1, array2;
        array1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19};

        //显示array1的内容。
        for (int i = 0; i < array1.length; i++){
            System.out.print(array1[i] + " ");
        }

        array2 = array1;//赋值array2变量等于array1

        //修改array2中的偶索引元素，使其等于索引值
        for (int i = 0; i < array2.length; i++){
            if (i % 2 == 0){
                array2[i] = i;
            }
        }

        //打印出array1
        System.out.println();
        for (int i = 0; i < array1.length; i++){
            System.out.print(array1[i] + " ");
        }

        //拷贝数组
        int[] array3 = new int[array1.length];
        for (int i = 0; i < array1.length; i++){
            array3[i] = array1[i];
        }

        for (int i = 0; i < array1.length; i++){
            array1[i] = i;
        }
        System.out.println();
        for (int i = 0; i < array1.length; i++){
            System.out.print(array1[i] + " ");
        }
        System.out.println();
        for (int i = 0; i < array3.length; i++){
            System.out.print(array3[i] + " ");
        }
    }
}

内存简析

int[] array1, array2;
array1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
array2 = array1;

for (int i = 0; i < array2.length; i++) {
    if (i % 2 == 0) {
    	array2[i] = i;
    }
}

int[] array1, array2;
array1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
//复制array1数组给array2
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
    array2[i] = array1[i];
}

练习2、数组的反转

/**
 * @author: huxingxin
 * @date: 2022/11/25 11:11:57
 * @description:
 */
public class Test2 {
    public static void main(String[] args) {
        String[] array = {"1", "2", "3", "4", "5", "6", "7"};

        //数组的反转
        String temp;
        for (int i = 0; i < array.length / 2; i++){
            temp = array[i];
            array[i] = array[array.length - i - 1];
            array[array.length - i - 1] = temp;
        }

        for (int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }

    }
}

练习3、数组的检索

/**
 * @author: huxingxin
 * @date: 2022/11/25 16:08:28
 * @description:
 */
public class Test3 {
    public static void main(String[] args) {
        String[] array = {"1", "2", "3", "4", "5", "6", "7"};

        String str = "5";

        //1、线性查找 地毯式搜索
        boolean flag = false;
        for (int i = 0; i < array.length; i++){
            if (str.equals(array[i])){
                System.out.println("字符串 的位置" + str + " 位于数组array下标为 " + i + " 的位置");
                flag = true;
                break;
            }
        }
        if (flag == false){
            System.out.println("很遗憾，没找到");
        }

        //2、二分法查找：每次比较中间值，折半的方式检索
        //前提：所要查找的数组必须有序
        int[] array1 = {10, 23, 45, 67, 90, 110, 345, 456, 765, 901};
        int number = 10;
        int start = 0;
        int end = array1.length - 1;
        int index;
        while (start <= end){
            index = (start + end) / 2;
            if (number > array1[index]){
                start = index + 1;
            }else if (number < array1[index]){
                end = index - 1;
            }else if (number == array1[index]){
                System.out.println("找到了，在数组array1下标为 " + index + " 的位置");
                break;
            }
//            System.out.println("start: " + start + " end :" + end + " index:" + index);
        }

        if (start > end){
            System.out.println("很遗憾，没找到");
        }
    }
}

练习4、数组的排序

/**
 * @author: huxingxin
 * @date: 2022/11/25 16:08:06
 * @description:
 */
public class Test4 {
    public static void main(String[] args) {
        int[] array = {23, 34, 0, 23, 45, 54, -1, -1, 60, 99, 34, 28};

        //冒泡排序
        int temp;
        for (int i = 0; i < array.length - 1; i++){//比较几轮
            for (int j = 0; j < array.length - 1 - i; j++){ //每次比较完毕 都减少一位
                temp = array[j];
                if (temp > array[j + 1]){ //把较大的数换到右边 从小到大排序
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }

        for (int i = 0; i < array.length - 1; i++){
            System.out.print(array[i] + " ");
        }
    }
}

五、Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

package com.notes._1Java基础编程._3数组;

import java.util.Arrays;

/**
 * @author: huxingxin
 * @date: 2022/11/25 17:11:31
 * @description:
 */
public class ArraysTest {
    public static void main(String[] args) {
        int[] array1 = {23, 34, 0, 23, 45, 54, -1, -1, 60, 99, 34, 28};
        int[] array2 = {23, 34, 0, 23, 45, 54, -1, -1, 60, 99, 34, 28};

        //1 boolean equals(int[] a,int[] b) 判断两个数组是否相等。
        boolean equals = Arrays.equals(array1, array2);
        System.out.println(equals);

        //2 String toString(int[] a) 输出数组信息。
        System.out.println(array1);
        String s = Arrays.toString(array1);
        System.out.println(s);


        //3 void fill(int[] a,int val) 将指定值填充到数组之中。
        Arrays.fill(array1, 0);
        String s1 = Arrays.toString(array1);
        System.out.println(s1); //[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]


        //4 void sort(int[] a) 对数组进行排序。
        Arrays.sort(array2); //快排
        String s2 = Arrays.toString(array2);
        System.out.println(s2);//[-1, -1, 0, 23, 23, 28, 34, 34, 45, 54, 60, 99]


        //5 int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。
        int i = Arrays.binarySearch(array2, 1);
        if (i >= 0){
            System.out.println(i);
        }else {
            System.out.println("未找到...");
        }

    }
}

六、数组使用中的常见异常

异常：编译时，不报错！！ 运行时报错，如果没有处理，程序会终止执行。