三、数组

1.数组的说明：
数组(array)：数的组合。-->多个相同数据类型的变量的组合
目的：为了方便在内存中，对多个变量进行统一的管理。

2.一维数组的声明与初始化
正确的方式：
//1.1数组的声明
int scores[];
String[] names;
//1.2 初始化
//静态初始化：数组的初始化和数组元素的赋值是同时进行的。
scores = new int[]{60,70,80,90,100};
//动态初始化：数组的初始化和数组元素的赋值是分开进行的。
names = new String[4];

int[] arr1 = {1,2,3};//简化写法:类型推断

错误的声明方式：
// int[] arr1 = new int[3]{1,2,4};

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

// int[] arr2;
// arr2 = {1,2,3};

3.一维数组元素的引用：通过下角标的方式调用。角标从0开始，到 数组的长度-1结束。
names[0] = "张扬";
names[1] = "杨睿";
names[2] = "司马旭升";

4.数组的属性：length：数组的长度
//总结：不管是静态初始化，还是动态初始化，一旦数组初始化完成，其长度就是确定的！且其长度不可变！

5.一维数组的遍历
for(int i = 0;i < scores.length;i++){
System.out.println(scores[i]);
}

6.一维数组元素的默认初始化值
1 整型数组：byte、short、int、long的默认数组元素的初始化值都为:0
2 浮点型数组：float、double 的默认数组元素的初始化值都为:0.0
3 字符型数组：char的默认数组元素的初始化值都为:'u0000' 或 0 (不要理解为:'0')
4 布尔型数组：boolean的默认数组元素的初始化值都为:false
5 引用数据类型数组:数组、接口、类的默认数组元素的初始化值为：null

7.一维数组的内存结构

1.如何理解二维数组？

1.数组本身属于引用数据类型
2.数组的元素，可以基本数据类型，也可以是引用数据类型。

3.二维数组的理解：一维数组中的元素，恰好又是一维数组。

2.二维数组的声明与初始化
正确的初始化方式：
//1.1静态初始化
String[][] arr1 = new String[][]{{"张扬","13200001111"},{"杨睿","13300001111"},{"杨飞","13400001111"}};
//1.2动态初始化1
int[] arr2[] = new int[3][2];
//1.2动态初始化2
int[][] arr3 = new int[3][];
arr3[0] = new int[3];
arr3[1] = new int[2];
arr3[2] = new int[4];

错误的初始化方式：
// int[][] arr4 = new int[3][2]{{3,2},{3,2},{4,3}};
// int[3][2] arr5 = new int[][]{{3,2},{3,2},{4,3}};

3.如何引用二维数组元素:通过下角标的方式进行数组元素的调用
System.out.println(arr1[1]);//地址值
System.out.println(arr1[1][0]);

4.二维数组的属性：length
System.out.println(arr1.length);//3
System.out.println(arr1[0].length);//2

5.遍历二维数组元素
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();

}

6.二维数组元素的默认初始化值
1.如果调用的是二维数组元素a，而元素a仍然是数组，根据元素a的数组元素的类型，决定其内部元素的默认初始化值。与一维数组的规定相同。
2.如果输出元素a,其值决定于是否初始化过。如果初始化过，则输出其地址值。如果没初始化过，则值为null.

short[][] arr1 = new short[3][2];
System.out.println(arr1[0][1]);//0
System.out.println(arr1[0]);//[S@15db9742
System.out.println(arr1);//[[S@6d06d69c

7.二维数组的内存结构

1.针对于数值型的数组：
求最大值、最小值、总和、平均值等
2.数组的赋值与复制
int[] array1,array2;
array1 = new int[]{1,2,3,4};
//赋值：
array2 = array1;//将array1地址值赋给array2,array1和array2就指向堆空间中同一个数组
//复制：重新创建一个数组array3,并将array1中的数据复制到array3中。
int[] array3 = new int[array1.length];
for(int i = 0;i < array1.length;i++){
array3[i] = array1[i];
}
3.数组元素的反转
//反转方式一：
// for(int i = 0,j = arr1.length - 1;i < j;i++,j--){
// String temp = arr1[i];
// arr1[i] = arr1[j];
// arr1[j] = temp;
// }

//反转方式二：
// for(int i = 0;i < arr1.length / 2;i++){
// String temp = arr1[i];
// arr1[i] = arr1[arr1.length - 1 - i];
// arr1[arr1.length - 1 - i] = temp;
// }
4.数组中指定元素的查找：①线性查找：普遍适用性 ②二分法查找：使用前提：数组是有序的。
//线性查找
String value = "CCC";
int i = 0;

for(;i < arr1.length;i++){
if(arr1[i].equals(value)){
System.out.println("找到指定元素，索引为：" + i);
break;
}
}

if(i == arr1.length){
System.out.println("未找到指定元素");

}

//二分法查找：要求此数组必须是序的。
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("未找打指定的元素");
}
5.数组的排序算法
选择排序
直接择排序、堆排序
交换排序
冒泡排序、快速排序
插入排序
直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序

理解：
1）衡量排序算法的优劣：
1.时间复杂度：分析关键字的比较次数和记录的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

2）内部排序 与 外部排序

冒泡排序的实现：--需要能手写出来

//实现冒泡排序:从小到大
        for(int i = 0;i < arr.length - 1;i++){

        for(int j = 0;j < arr.length - 1 - i;j++){//比较相邻的两个元素的值所需要的索引
            if(arr[j] > arr[j + 1]){
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

Arrays工具类的使用

        int[] arr1 = {1,2,2,34,5,6};
        int[] arr2 = {2,1,2,34,5,6};
        //1.equals():比较两个数组的元素，是否完全相同。
        boolean b = Arrays.equals(arr1, arr2);
        System.out.println(b);
        
        //2.toString():输出显示数组的具体的元素
        System.out.println(arr1);//地址值
        System.out.println(Arrays.toString(arr1));
        
        //3.将数组的所元素重新赋值，赋值为参数2的值
//        Arrays.fill(arr1, 10);
//        System.out.println(Arrays.toString(arr1));
        
        //4.sort():排序,底层使用的是快速排序实现的。
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));//[1, 2, 2, 5, 6, 34]
        
        //5.binarySearch():使用二分法，在数组中查找指定元素的索引。前提：要求此数组是序的。
        int index = Arrays.binarySearch(arr1, 55);
        System.out.println(index);

数组的常见异常

        //1.数组角标越界异常：ArrayIndexOutOfBoundsException
        int[] arr1 = new int[10];//角标：0-9
        
        arr1[0] = 10;
        arr1[9] = 20;
        
//        arr1[10] = 30;
//        arr1[-1] = 1;
        
        //2.空指针异常：NullPointerException
        //举例1：
//        int[] arr2 = new int[10];
//        arr2 = null;
//        System.out.println(arr2[0]);//空指针异常
        
        //举例2：
//        int[][] arr3 = new int[3][];
//        System.out.println(arr3[0]);//null
////        arr3[0] = new int[]{1,2,3};
//        System.out.println(arr3[0][0]);//空指针异常
        
        //举例3：
        String[] arr4 = new String[4];
        System.out.println(arr4[0].toString());