03.数组

一.数组的概述

1.数组的理解

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

2.数组相关的概念

• 数组名
• 元素
• 角标、下标、索引
• 数组的长度：元素的个数

3.数组的特点

1. 数组是有序排列的
2. 数组属于引用数据类型的变量。数组的元素，即可以是基本数据类型，也可以是引用数据类型
3. 创建数组对象会在内存中开辟一整块连续的空间
4. 数组的长度一旦确定，就不能修改。

4.数组的分类

• 照维数：一维数组、二维数组
• 照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

二.一维数组

1.一维数组的声明与初始化

正确的方式:

int num; // 声明
num = 10; // 初始化
int id = 1001; // 声明+初始化

int [] ids; // 声明
// 1.1 静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1,2,3,4};
// 1.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
String [] names = new String[5];

int [] arr4 = [1,2,3,4];// 类型推断

2.一维数组元素的引用

通过索引或者下标调用

3.数组的属性:length

说明：数组一旦初始化，其长度就是确定的。arr.length。数组长度一旦确定，就不可修改。

4.一维数组的遍历

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

5.一维数组元素的默认初始化值

• 数组元素是整型：0
• 数组元素是浮点型：0.0
• 数组元素是 char 型：0 或'\u0000',而非'0'
• 数组元素是 boolean 型：false
• 数组元素是引用数据类型：null

三.二维数组

1.如何理解二维数组？

数组属于引用数据类型
数组的元素也可以是引用数据类型
一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

2.二维数组的声明与初始化

正确的方式

int [] arr = new int []{1,3,4};// 一维数组
// 静态初始化
int [][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
// 动态初始化1
String [][] arr2 = new String[3][2];
// 动态初始化2
String [][] arr3 = new String[3][];
// 也是正确的写法
int [] arr4[] = new int [][]{{1,2,3},{4,5},{6,7,8}};
int [] arr5[] = {{1,2,3},{4,5},{6,7,8}};

3.如何调用二维数组元素

System.out.println(arr1[0][1]);

4.二维数组的属性

System.out.println(arr1[0].length);

5.遍历二维数组元素

for(int i = 0;i < arr.length;i++){
       for(int j = 0;j < arr[i].length;j++){
        Syetem.out.println(arr[i][j]);
    }
}

6.二维数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内存数组的元素

int [][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等
数组元素的默认初始化值
针对于初始化方式一：比如:int [][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如:int [][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。

四.数组的常见算法

1.数组的创建与元素赋值

杨辉三角（二维数组）、回形数（二维数组）、6 个数，1-30 之间随机生成且不重复。

2.针对于数值型的数组

最大值、最小值、总和、平均数等。

3.数组的赋值与复制

int [] array1,array2;
array1 = new int[]{1,2,3,4};

3.1 赋值

array2 = array1;

如何理解:将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。

3.2 复制

array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
    array2[i] = array1[i]
};

如何理解:我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

4.数组元素的反转

// 方式一：
for(int i = 0;i < arr.length / 2;i++){
    String temp = arr[i];
    arr[i] = arr[arr.length - i - 1];
    arr[arr.length - 1 - i] = temp;
};
// 方式二：
for(int i = 0,j = arr.length - 1; i < j;j--){
    String temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
};

5.数组中指定元素的查找：搜索、检索

5.1 线性查找

实现思路：通过遍历的方式，一个一个的数据进行比较、查找。

适用性：具有普遍适用性。

5.2 二分法查找

实现思路：每次比较中间值，折半的方式检索。

适用性：（前提：数组必须有序）

6.数组的排序算法

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

理解:

1. 衡量排序算法的优劣 时间复杂度、空间复杂度、稳定性
2. 排序的分类：内部排序 与 外部排序（需要借助于磁盘）
3. 不同排序算法的时间复杂度
4. 手写冒泡排序

int [] arr = new int[]{43,32,54,65,76,87,-21,32,11,33};
// 冒泡排序
for(int i = 0; i < arr.length -1 ;i++){
    for(int j = 0; j < arr.length -1 ;j++){
       if(arr[j] > arr[j+1]){
           int temp = arr[j];
           arr[j] = arr[j+1];
           arr[j+1] = temp;
       }
    };
};

五.Arrays 工具类的使用

1.理解

• 定义在java.utils包下。
• Arrays：提供了很多操作数组的方法。

2.使用

// 1.boolean equals(int[] a, int[] b):判断两个数组是否相等。
int [] arr1 = new int []{1,2,3,4};
int [] arr2 = new int []{1,3,2,4};
boolean isEquals = Arrays.equals(arr1,arr2);
System.out.println(isEquals);

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

// 3.void fill(int[] a, int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));

六.数组的常见异常

1.数组角标越界异常：ArrayIndexOutOfBoundsException

int [] arr = new int []{1,2,3,4};
for(int i = 0;i <= arr.length;i++){
   System.out.println(arr[i]);
};

2.空指针异常：NullPointerException

// 情况一：
int [] arr1 = new int []{1,2,3};
arr1 = null;
System.out.println(arr[0]);

// 情况二：
int [][] arr2 = new int [4][];
System.out.println(arr2[0][0]);

// 情况三：
String[] arr3 = new String [][{"AA","BB","CC"}];
arr3[0] = null;
System.out.println(arr3[0].toString());

小知识: 一旦程序出现异常，就终止执行。