深入浅出 Java 数组：从基础到进阶
数组是 Java 中最基础的数据结构之一，它能有效地存储和操作相同类型的一组数据。本文将从基础概念、创建、操作方法、进阶用法、常见错误等方面全面讲解 Java 数组，帮助你掌握数组的精髓。
1. 数组的概念
数组可以被理解为一个容器，用来存储一组相同数据类型的值。每个元素在数组中都有一个唯一的索引，从 0 开始，可以用这个索引访问数组中的每个元素。
用图示说明：
+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 |
+---+---+---+---+---+---+
| | | | | | |
+---+---+---+---+---+---+
示例：
假如我们要存储 5 个学生的成绩，可以使用一个 int 类型的数组来存储：
int[] scores = {85, 90, 78, 92, 88};
这个数组 scores 包含 5 个整型元素，索引从 0 开始到 4，分别存储了 5 个学生的成绩。
2. 数组的类型
Java 中的数组可以存储各种数据类型，包括基本数据类型和引用数据类型。
2.1 基本数据类型数组
| 数据类型 | 说明 | 示例 |
|---|---|---|
int |
整数 | int[] ages = {18, 20, 22, 25}; |
double |
双精度浮点数 | double[] heights = {1.75, 1.80, 1.65}; |
char |
字符 | char[] letters = {'A', 'B', 'C'}; |
boolean |
布尔类型 | boolean[] isPassed = {true, false, true}; |
2.2 引用数据类型数组
| 数据类型 | 说明 | 示例 |
|---|---|---|
String |
字符串 | String[] names = {"Alice", "Bob", "Charlie"}; |
| 自定义类 | 自定义类对象 | Car[] cars = {new Car(), new Car()}; |
3. 数组的创建和初始化
创建数组主要有两种方式：
3.1 声明并初始化数组
- 声明数组：使用数据类型和数组名，加上方括号
[]来声明数组。例如：int[] ages; - 初始化数组：为数组分配内存空间并赋值。
- 直接赋值：
int[] ages = {18, 20, 22, 25}; - 使用
new关键字：int[] ages = new int[4];// 创建一个长度为4的int数组，此时数组元素默认值为0。
- 直接赋值：
3.2 使用 new 关键字创建数组
- 使用
new关键字可以动态地创建数组。 例如：String[] names = new String[3];// 创建一个长度为3的String数组，初始元素为空。
4. 数组的访问
可以使用索引访问数组元素，索引从 0 开始。
示例：
int[] ages = {18, 20, 22, 25};
System.out.println(ages[0]); // 输出第一个元素的值：18
System.out.println(ages[2]); // 输出第三个元素的值：22
5. 数组的遍历
可以使用循环遍历数组元素。
示例：
- 使用
for循环遍历：
int[] scores = {85, 90, 78, 92, 88};
for (int i = 0; i < scores.length; i++) {
System.out.println("第 " + (i + 1) + " 个学生的成绩：" + scores[i]);
}
- 使用增强
for循环遍历：
int[] scores = {85, 90, 78, 92, 88};
for (int score : scores) {
System.out.println("成绩：" + score);
}
6. 数组的常用操作
6.1 数组的排序
可以使用 Arrays.sort() 方法对数组进行排序。
int[] numbers = {5, 2, 8, 1, 9};
Arrays.sort(numbers); // 对数组进行升序排序
for (int number : numbers) {
System.out.print(number + " ");
} // 输出： 1 2 5 8 9
6.2 数组的查找
可以使用 Arrays.binarySearch() 方法在已排序的数组中查找元素。
int[] numbers = {1, 2, 5, 8, 9};
int index = Arrays.binarySearch(numbers, 5); // 查找数字 5
System.out.println(index); // 输出： 2 (数字 5 的索引)
6.3 数组的复制
可以使用 Arrays.copyOf() 方法复制数组。
int[] ages = {18, 20, 22, 25};
int[] newAges = Arrays.copyOf(ages, ages.length); // 将 ages 数组复制到 newAges 数组
6.4 数组的比较
可以使用 Arrays.equals() 方法比较两个数组是否相等。
int[] ages = {18, 20, 22, 25};
int[] newAges = {18, 20, 22, 25};
boolean isEqual = Arrays.equals(ages, newAges); // 比较 ages 数组和 newAges 数组是否相等
6.5 数组的填充
可以使用 Arrays.fill() 方法用指定的值填充数组。
int[] numbers = new int[5];
Arrays.fill(numbers, 10); // 用 10 填充 numbers 数组
6.6 数组的转换
可以使用 Arrays.toString() 方法将数组转换为字符串。
int[] ages = {18, 20, 22, 25};
String agesString = Arrays.toString(ages); // 将 ages 数组转换为字符串
System.out.println(agesString); // 输出：[18, 20, 22, 25]
6.7 数组的深度复制
对于引用类型的数组，使用 Arrays.copyOf() 方法只能实现浅复制，即只是复制指向对象的引用，而不是复制对象本身。如果需要复制对象本身，需要使用深度复制方法。
class Car {
String brand;
String model;
public Car(String brand, String model) {
this.brand = brand;
this.model = model;
}
}
public class Main {
public static void main(String[] args) {
Car[] cars1 = {new Car("Toyota", "Camry"), new Car("Honda", "Civic")};
Car[] cars2 = Arrays.copyOf(cars1, cars1.length); // 浅复制，cars2 指向 cars1 中元素的引用
cars2[0].brand = "Ford"; // 修改 cars2 中的第一个元素
System.out.println("cars1[0].brand: " + cars1[0].brand); // 输出：Ford
System.out.println("cars2[0].brand: " + cars2[0].brand); // 输出：Ford
}
}
为了实现深度复制，需要手动创建新的对象并复制属性值：
class Car {
String brand;
String model;
public Car(String brand, String model) {
this.brand = brand;
this.model = model;
}
}
public class Main {
public static void main(String[] args) {
Car[] cars1 = {new Car("Toyota", "Camry"), new Car("Honda", "Civic")};
Car[] cars2 = new Car[cars1.length]; // 创建一个新的 Car 数组
for (int i = 0; i < cars1.length; i++) {
cars2[i] = new Car(cars1[i].brand, cars1[i].model); // 创建新的 Car 对象并复制属性
}
cars2[0].brand = "Ford"; // 修改 cars2 中的第一个元素
System.out.println("cars1[0].brand: " + cars1[0].brand); // 输出：Toyota
System.out.println("cars2[0].brand: " + cars2[0].brand); // 输出：Ford
}
}
7. 多维数组
多维数组可以存储多个相同类型的数组。例如，二维数组可以表示一个表格，三维数组可以表示一个立方体。
7.1 声明和创建多维数组
int[][] table = new int[3][4]; // 创建一个 3 行 4 列的二维数组
7.2 访问多维数组元素
int[][] table = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
System.out.println(table[1][2]); // 输出： 7 (第二行第三列元素)
7.3 遍历多维数组
可以使用嵌套循环遍历多维数组。
int[][] table = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
for (int i = 0; i < table.length; i++) {
for (int j = 0; j < table[i].length; j++) {
System.out.print(table[i][j] + " ");
}
System.out.println();
}
8. 数组的进阶用法
8.1 使用数组实现其他数据结构
数组可以用来实现其他数据结构，例如：
- 栈 (Stack): 栈是后进先出的数据结构，可以用数组实现。
- 队列 (Queue): 队列是先进先出的数据结构，可以用数组实现。
- 链表 (Linked List): 链表是一种动态数据结构，可以用数组来模拟。
8.2 使用数组实现算法
数组是许多算法的基础，例如：
- 排序算法: 例如冒泡排序、插入排序、快速排序等。
- 查找算法: 例如二分查找、线性查找等。
- 矩阵运算: 例如矩阵加法、矩阵乘法等。
8.3 使用数组实现图形处理
数组可以用来存储图像的像素数据，并用于实现各种图形处理操作。
8.4 使用数组实现游戏开发
数组可以用来存储游戏角色的位置、属性、地图信息等数据。
9. 数组的常见错误
- 数组越界: 访问数组时，索引超出数组的范围，会导致
ArrayIndexOutOfBoundsException错误。 - 空指针异常: 访问一个未初始化的数组或指向空对象的数组元素，会导致
NullPointerException错误。 - 数组长度固定: 数组一旦创建，其长度就固定了，无法动态改变。
10. 总结
数组的优缺点：
| 优点 | 缺点 |
|---|---|
| 存储相同类型的一组值 | 数组的长度固定，无法动态调整 |
| 访问元素速度快 | 如果需要动态存储，需要使用其他数据结构，例如链表 |
| 方便操作 | 数组越界和空指针错误是常见的错误类型 |
表格总结：
| 概念 | 描述 | 示例 |
|---|---|---|
| 数组 | 用来存储相同数据类型的一组值，每个元素都有唯一的索引 | int[] scores = {85, 90, 78, 92, 88}; |
| 数组创建 | 使用 new 关键字或直接赋值初始化 |
int[] ages = new int[4]; 或 int[] ages = {18, 20, 22, 25}; |
| 数组访问 | 使用索引访问数组元素，索引从 0 开始 | System.out.println(ages[0]); // 输出第一个元素的值 |
| 数组遍历 | 使用循环遍历数组元素 | 使用 for 循环或增强 for 循环遍历 |
| 数组排序 | 使用 Arrays.sort() 方法对数组进行排序 |
Arrays.sort(numbers); |
| 数组查找 | 使用 Arrays.binarySearch() 方法在已排序的数组中查找元素 |
int index = Arrays.binarySearch(numbers, 5); |
| 数组复制 | 使用 Arrays.copyOf() 方法复制数组 |
int[] newAges = Arrays.copyOf(ages, ages.length); |
| 数组比较 | 使用 Arrays.equals() 方法比较两个数组是否相等 |
boolean isEqual = Arrays.equals(ages, newAges); |
11. 总结
数组是 Java 中非常重要的数据结构，它能帮助我们有效地存储和操作数据。但使用数组时要注意避免常见的错误，如数组越界和空指针异常。同时，也可以使用数组实现其他数据结构和算法，以提高程序的效率和可读性。
