Java 数组的定义与使用

1 数组的创建及初始化

1.1 数组的创建

T[] 数组名 = new T[N];

**T：**表⽰数组中存放元素的类型
**T[]：**表⽰数组的类型
**N：**表⽰数组的⻓度

int[] array1 = new int[10]; // 创建⼀个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建⼀个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建⼀个可以容纳3个字符串元素的数组

1.2数组的初始化

数组的初始化主要分为动态初始化以及静态初始化。

1. 动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array = new int[10];

2. 静态初始化：在创建数组时不直接指定数据元素个数，⽽直接将具体的数据内容进⾏指定
   语法格式： T[] 数组名称 = {data1, data2, data3, ..., datan};

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

【注意事项】
静态初始化虽然没有指定数组的⻓度，编译器在编译时会根据{}中元素个数来确定数组的⻓度。
静态初始化时, {}中数据类型必须与[]前数据类型⼀致。
静态初始化可以简写，省去后⾯的new T[]。

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};

如果没有对数组进⾏初始化，数组中元素有其默认值
如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值.
如果数组中存储元素类型为引⽤类型，默认值为nul.

String[] words = new String[];

2 数组的基本使⽤

2.1数组中元素访问

数组在内存中是⼀段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。⽐如：

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
// 也可以通过[]对数组中的元素进⾏修改
array[0] = 100;
System.out.println(array[0]);

【注意事项】
1 数组是⼀段连续的内存空间，因此⽀持随机访问，即通过下标访问快速访问数组中任意位置的元素.
2下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组中只有3个元素，下标⼀次为：0 1 2，array[3]
下标越界
// 执⾏结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException

抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使⽤数组⼀定要注意下标的访
问谨防越界.

2.2遍历数组

所谓 "遍历" 是指将数组中的所有元素都访问⼀遍, 访问是指对数组中的元素进⾏某种操作，⽐如：打印。

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);

上述代码可以起到对数组中元素遍历的⽬的，但问题是：

1. 如果数组中增加了⼀个元素，就需要增加⼀条打印语句
2. 如果输⼊中有100个元素，就需要写100个打印语句
3. 如果现在要把打印修改为给数组中每个元素加1，修改起来⾮常⿇烦。
   通过观察代码可以发现，对数组中每个元素的操作都是相同的，则可以使⽤循环来进⾏打印。

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < 5; i++){
System.out.println(array[i]);
}

改成循环之后，上述三个缺陷可以全部2和3问题可以全部解决，但是⽆法解决问题1。那能否获取到数组的⻓度呢？
注意：在数组中可以通过****数组对象.length 来获取数组的⻓度

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}

也可以使⽤ for-each 遍历数组

int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}

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

3 数组是引⽤类型

3.1 基本类型变量与引⽤类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
⽽引⽤数据类型创建的变量，⼀般称为对象的引⽤，其空间中存储的是对象所在空间的地址。

public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}

在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main⽅法对应的栈帧中分配。
a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
array是数组类型的引⽤变量，其内部保存的内容可以简单理解成是数组在堆空间中的⾸地址。

从上图可以看到，引⽤变量并不直接存储对象本⾝，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引⽤变量便可以去操作对象。有点类似C语⾔中的指针，但是Java中引⽤要⽐指针的操作更简单。

3.2 认识 null

null 在 Java 中表⽰ "空引⽤" , 也就是⼀个不指向对象的引⽤

int[] arr = null;
System.out.println(arr[0]);
// 执⾏结果
Exception in thread "main" java.lang.NullPointerException

null 的作⽤类似于 C 语⾔中的 NULL (空指针), 都是表⽰⼀个⽆效的内存位置. 因此不能对这个内存进⾏
任何读写操作. ⼀旦尝试读写, 就会抛出 NullPointerException.

注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联.

4. 操作数据⼯具类Arrays与数组练习

4.1 数组转字符串

import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
// 执⾏结果
[1, 2, 3, 4, 5, 6]

使⽤这个⽅法后续打印数组就更⽅便⼀些.
Java 中提供了 java.util.Arrays 包, 其中包含了⼀些操作数组的常⽤⽅法

import java.util.Arrays;
public static void func(){
// newArr和arr引⽤的是同⼀个数组
// 因此newArr修改空间中内容之后，arr也可以看到修改的结果
int[] arr = {1,2,3,4,5,6};
int[] newArr = arr;
newArr[0] = 10;
System.out.println("newArr: " + Arrays.toString(arr));
// 使⽤Arrays中copyOf⽅法完成数组的拷⻉：
// copyOf⽅法在进⾏数组拷⻉时，创建了⼀个新的数组
// arr和newArr引⽤的不是同⼀个数组
arr[0] = 1;
newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
// 因为arr修改其引⽤数组中内容时，对newArr没有任何影响
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
// 拷⻉某个范围.
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));
}

注意：数组当中存储的是基本类型数据时，不论怎么拷⻉基本都不会出现什么问题，但如果存储的是引⽤数据类型，拷⻉时需要考虑深浅拷⻉的问题，关于深浅拷⻉在后续详细给⼤家介绍。

4.2 数组逆序

给定⼀个数组, 将⾥⾯的元素逆序排列.
思路
设定两个下标, 分别指向第⼀个元素和最后⼀个元素. 交换两个位置的元素.
然后让前⼀个下标⾃增, 后⼀个下标⾃减, 循环继续即可.
代码⽰例

public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr) {
int left = 0;
int right = arr.length - 1;
while (left < right) {
int tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
left++;
right--;
}
}

**重点：**一些其他的数组方法

        Arrays.sort(array);//    快排
        int dex = Arrays.binarySearch(array,3);//   二分
        int[] copy = Arrays.copyOf(array,array.length);//    拷贝
        boolean flg = Arrays.equals(arr1,arr2);//     对比数组元素是否相同
        Arrays.fill(arr,3);//  填充数组元素
        Arrays.fill(arr,2,8,5);
        boolean flg=Arrays.deepEquals(array);//     二维数组对比是否相同

5. ⼆维数组

5.1 普通的⼆维数组

⼆维数组本质上也就是⼀维数组, 只不过每个元素⼜是⼀个⼀维数组.
基本语法

数据类型[][] 数组名称 = new 数据类型 [⾏数][列数] { 初始化数据 };

⾏不可以省略，列可以省略

int[][] arr = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
// 执⾏结果
1 2 3 4
5 6 7 8
9 10 11 12

⼆维数组是特殊的⼀维数组，⼀维数组的每个元素⼜是⼀个数组
arr.length 代表⼆维数组的⾏数
arr[i].length 代表⼆维数组的列数

5.2 不规则的⼆维数组

不规则的⼆维数组指的是，⼆维数组的列在定义的时候，没有确定。

int[][] array = new int[2][];
array[0] = new int[3];
array[1] = new int[5];

上述⼆维数组就不是⼀个规则的⼆维数组。第1⾏有3列，第2⾏有5列。