【Java】数组

一. 为什么要有数组？

数组本质上就是让我们能 “批量” 创建相同类型的变量。

例如：
如果需要表示两个整型数据，那么直接创建两个变量即可 int a; int b;
如果需要表示五个整型数据，那么可以创建五个变量 inta1; int a2; int a3; int a4; int a5;
但是如果需要表示一万个数据, 那么就不能创建一万个变量了。这时候就需要使用数组来帮我们批量创建。

注意事项：在 Java 中, 一个数组所包含的变量必须是相同类型的。

二. 什么是数组？

1. 基本语法

定义数组有如下三种方式：

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

补充说明

• 第一、二种定义方式本质是一样的，只不过第一种简化少写了new 类型[]
• 第三种定义方式规定了元素个数之后就不能再初始化给值，默认元素的值为0
• 其实数组也可以写成：int arr[ ] = {1, 2, 3}; 这样就和 C 语言一样了。但是我们还是更推荐写成 int[] arr 的形式，显示说明 int 和 [ ] 是一个整体。

三种写法中，最经常用到的是第一种写法。

2. 数组的本质

数组变量的本质是一个引用变量，而引用变量其实就是一个用来存地址的变量。

因为引用变量所存储的数据是一个地址，而这个地址一般都是指向一块在堆上动态开辟的空间，这块空间才是真正存储了我们初始化出来的数据，所以我们说某个引用（变量）指向了一个对象，这个对象就是那个地址之下存储的数据。

再看下面这个例子，可以帮助我们理解 数组的本质是一个引用变量 这句话的含义：

int[] array1 = {1, 2, 3};
// arrar2这个引用指向了
// array1这个引用所指向的对象
int[] arrar2 = array1;
System.out.println(array1);
System.out.println(arrar2);

--------结果如下--------
[I@1b6d3586
[I@1b6d3586

解释说明：

三. 数组的使用

1. 获取长度、访问元素

int[] arr = {1, 2, 3};
// 获取数组长度
System.out.println("length: " + arr.length);
// 读取数组中的元素
System.out.println(arr[0]);
// 修改数组中的元素
arr[0] = 99;
System.out.println(arr[0]);

--------结果如下--------
length: 3
1
99

注意事项：

1. 使用数组名.length能够获取到数组的长度，数组名后的那个点是成员访问操作符。
2. 使用 [ ] 可以按下标取数组元素，需要注意 下标从 0 开始计数
3. 使用 [ ] 操作既能读取元素, 也能修改元素
4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常。

2. 遍历数组

所谓 “遍历” 就是指将数组中的所有元素都访问一遍，不重不漏。通常需要搭配循环语句。

方法一：使用 for 循环遍历数组

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

--------结果如下--------
1
2
3

方法二：使用 for-each 遍历数组
for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错

int[] arr = {1, 2, 3};
// 注意:对x的修改操作并不会影响数组元素的值
for (int x : arr){
   System.out.println(x);
}

--------结果如下--------
1
2
3

补充：使用 toString 打印数组
toString 这个方法属于 Arrays 类，所以我们需要引入 Arrays 类：import java.util.Arrays;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        System.out.println(Arrays.toString(a));
    }
}

--------结果如下--------
[1, 2, 3]

3. 下标越界、空引用

如果抛出程序抛出了 java.lang.ArrayIndexOutOfBoundsException 这个异常，就说明数组越界了。使用数组一定要谨防下标越界。

int[] arr = {1, 2, 3};
System.out.println(arr[100]);

--------结果如下--------
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
	at Test.main(Test.java:2)

如果抛出程序抛出了 Exception in thread "main" java.lang.NullPointerException 这个异常，就说我们有尝试去访问一款空地址，这是不允许的。

int[] arr = null;
System.out.println(arr[0]);

--------结果如下--------
Exception in thread "main" java.lang.NullPointerException
	at Test.main(Test.java:2)

4. 数组作为函数参数

数组作为函数参数进行传递的时候，其实还是按值传递，只不过传递的值是一个地址，那么在函数内部对这个数组就会出现两种情况：

1. 形参修改指向。这只会影响到形参的指向
   
2. 形参修改指向对象的值
   

5. 数组作为函数返回值

四. 数组拷贝

1. 手动拷贝

下面代码不叫拷贝，因为此时只有一个数组对象：

int[] arr1 = {1, 2, 3};
System.out.println(Arrays.toString(arr1));
int[] arr2 = arr1;
System.out.println(Arrays.toString(arr1));

--------结果如下--------
[1, 2, 3]
[1, 2, 3]

真正的拷贝应该重新开辟出一块和原数组一样大的空间，然后遍历原数组的元素，把它们的值逐个拷贝到新空间：

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

--------结果如下--------
[1, 2, 3]

2. 使用库函数拷贝

函数原型
dataType[] Arrays.copyOf(dataType[] srcArray,int length);

说明

• Arrays 类的 copyOf() 方法是复制数组至指定长度
• srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度
• 使用这种方法复制数组时，默认从原数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。如果 length 大于 srcArray.length，则目标数组中采用默认值填充；如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。

举例

int[] arr1 = {1, 2, 3};
int[] arr2 = Arrays.copyOf(arr1, 3);
System.out.println(Arrays.toString(arr2));
        
--------结果如下--------
[1, 2, 3]

五. Arrays中几个常用的方法

1. 对数组进行排序

方法：Arrays.sort(int[] a)

2. 拷贝数组

方法：dataType[] Arrays.copyOf(dataType[] srcArray,int length)

3. 对数组元素进行填充

方法：Arrays.fill(a1, value);

4. 把数组转化为字符串，方便打印

方法：string Arrays.toString(dataType[] )

六. 二维数组

1. 定义方式

和一维数组一样，二维数组的定义方式也有三种：

int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
int[][] array2 = new int[][]{{1, 2, 3}, {4, 5, 6}};
int[][] array3 = new int[2][];// 列数写不写都可以

2. 二维数组的本质

我们在学习C语言中的二维数组时，都应该听说过这句话：“二维数组是特殊的一维数组”，Java里面把这句话诠释得很好。

不同于 C/C++ 中的二维数组，他们要求定义时必须确定列数，而Java中的二维数组在定义时必须确定行数，列数无所谓：

// 不指定列数
int[][] array1 = new int[2][];
System.out.println(Arrays.deepToString(array1));
// 指定列数
int[][] array2 = new int[2][3];
System.out.println(Arrays.deepToString(array2));
        
--------结果如下--------
[null, null]
[[0, 0, 0], [0, 0, 0]]

3. 二维数组的三种遍历方式

3.1 for 循环

int[][] arr = {{1, 2, 3}, {4, 5, 6}};
for(int i = 0; i < arr.length; ++i){
    for (int j = 0; j < arr[i].length; ++j){
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}
        
--------结果如下--------
1 2 3 
4 5 6 

3.2 for - each

这里拿出的值只是数组元素的拷贝，对它们的修改并不会影响原数组的元素

int[][] arr = {{1, 2, 3}, {4, 5, 6}};
for(int[] ret : arr){
    for(int x : ret){
        System.out.print(x + " ");
    }
    System.out.println();
}
        
--------结果如下--------
1 2 3 
4 5 6 

3.3 使用 Arrar.deepToString 函数

int[][] arr = {{1, 2, 3}, {4, 5, 6}};
System.out.println(Arrays.deepToString(arr));
        
--------结果如下--------
[[1, 2, 3], [4, 5, 6]]