Java数组的使用与操作
Java 数组基础
在 Java 中，数组是一种用于存储多个相同类型数据的容器。它在内存中是连续分配的，这使得对数组元素的访问非常高效。数组的大小在创建时就被确定，之后不能动态改变。
数组的声明
要使用数组，首先需要声明它。声明数组有两种常见的方式：
// 方式一：数据类型[] 数组名;
int[] numbers;
// 方式二：数据类型 数组名[];
double scores[];
这两种声明方式在功能上是等效的，但第一种方式（数据类型[] 数组名）更符合 Java 的标准风格，推荐使用这种方式。声明数组仅仅是在栈内存中为数组变量分配了空间，此时数组还没有分配实际的内存来存储元素，也就是还没有初始化。
数组的初始化
数组声明后需要进行初始化，为其分配内存并赋值。初始化有以下几种方式：
静态初始化：在初始化数组时直接指定数组元素的值。
// 静态初始化一个整数数组
int[] numbers = {1, 2, 3, 4, 5};
// 静态初始化一个字符串数组
String[] names = {"Alice", "Bob", "Charlie"};
动态初始化：在初始化数组时只指定数组的大小，之后再为数组元素赋值。
// 动态初始化一个大小为 5 的整数数组
int[] numbers = new int[5];
// 为数组元素赋值
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;
在动态初始化中，Java 会根据数组的类型，为数组元素赋予默认值。例如，整数类型数组的默认值是 0，浮点类型数组的默认值是 0.0，布尔类型数组的默认值是 false，对象类型数组的默认值是 null。
访问数组元素
数组元素通过索引来访问，索引从 0 开始，到数组长度减 1 结束。例如，对于一个长度为 n 的数组，其有效索引范围是 0 到 n - 1。
int[] numbers = {1, 2, 3, 4, 5};
// 访问数组的第一个元素
int firstNumber = numbers[0];
// 访问数组的最后一个元素
int lastNumber = numbers[4];
如果访问数组时使用了超出有效范围的索引，会抛出 ArrayIndexOutOfBoundsException 异常。这是在编写数组相关代码时需要特别注意的地方。
多维数组
在 Java 中，除了一维数组，还支持多维数组。多维数组本质上是数组的数组。以二维数组为例，它可以看作是一个表格，有行和列。
二维数组的声明与初始化
静态初始化：
// 静态初始化一个 2 行 3 列的二维整数数组
int[][] matrix = {
{1, 2, 3},
{4, 5, 6}
};
动态初始化：
// 动态初始化一个 3 行 4 列的二维整数数组
int[][] matrix = new int[3][4];
// 为二维数组元素赋值
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
matrix[i][j] = i * 4 + j;
}
}
访问二维数组元素
访问二维数组元素需要使用两个索引，第一个索引表示行，第二个索引表示列。
int[][] matrix = {
{1, 2, 3},
{4, 5, 6}
};
// 访问第一行第二列的元素
int element = matrix[0][1];
同样，对于多维数组，访问元素时索引也不能超出其有效范围，否则会抛出 ArrayIndexOutOfBoundsException 异常。
数组的常见操作
数组的遍历
遍历数组是指按顺序访问数组中的每一个元素。对于一维数组，常用的遍历方式有以下几种：
使用 for 循环：
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
使用增强 for 循环（for - each 循环）：
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
System.out.println(number);
}
增强 for 循环更加简洁，适用于只需要读取数组元素而不需要修改索引的情况。但它不能用于在遍历过程中修改数组元素的索引（例如跳过某些元素），这种情况下还是需要使用传统的 for 循环。
对于二维数组，遍历需要使用嵌套循环：
int[][] matrix = {
{1, 2, 3},
{4, 5, 6}
};
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
数组的复制
在 Java 中，数组的复制有多种方式。
使用 System.arraycopy() 方法：
int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];
System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);
System.arraycopy() 方法的参数依次为：源数组、源数组的起始索引、目标数组、目标数组的起始索引、要复制的元素个数。这种方式效率较高，因为它是由底层的 C 或 C++ 代码实现的。
使用 Arrays.copyOf() 方法：
int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = Arrays.copyOf(sourceArray, sourceArray.length);
Arrays.copyOf() 方法会创建一个新的数组，并将源数组的元素复制到新数组中。它的第二个参数指定了新数组的长度。如果新数组长度大于源数组长度，剩余元素将被填充为默认值；如果新数组长度小于源数组长度，超出部分的元素将被截断。
使用 clone() 方法：
int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = sourceArray.clone();
clone() 方法会创建一个与源数组长度相同的新数组，并将源数组的元素复制到新数组中。需要注意的是，对于多维数组，clone() 方法执行的是浅拷贝，即只复制了最外层数组，内层数组仍然是引用。
数组的排序
Java 提供了多种数组排序的方法。
使用 Arrays.sort() 方法：
int[] numbers = {5, 3, 1, 4, 2};
Arrays.sort(numbers);
for (int number : numbers) {
System.out.print(number + " ");
}
Arrays.sort() 方法对数组进行升序排序。它使用的是 Dual - pivot Quicksort 算法，对于大多数情况都有较好的性能表现。
对于对象数组，如果要进行排序，对象的类需要实现 Comparable 接口，并重写 compareTo() 方法来定义比较规则。
class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person other) {
return this.age - other.age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class ArraySortExample {
public static void main(String[] args) {
Person[] people = {
new Person("Alice", 25),
new Person("Bob", 20),
new Person("Charlie", 30)
};
Arrays.sort(people);
for (Person person : people) {
System.out.println(person);
}
}
}
在这个例子中，Person 类实现了 Comparable 接口，compareTo() 方法根据年龄进行比较，从而实现了 Person 对象数组的排序。
数组与方法
在 Java 中，数组可以作为方法的参数和返回值。
数组作为方法参数
public class ArrayAsParameter {
public static void printArray(int[] array) {
for (int number : array) {
System.out.print(number + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
printArray(numbers);
}
}
在这个例子中，printArray() 方法接受一个整数数组作为参数，并将数组元素打印出来。
数组作为方法返回值
public class ArrayAsReturnValue {
public static int[] createArray() {
int[] array = {1, 2, 3, 4, 5};
return array;
}
public static void main(String[] args) {
int[] result = createArray();
for (int number : result) {
System.out.print(number + " ");
}
}
}
createArray() 方法创建一个整数数组并返回，在 main() 方法中接收返回的数组并进行遍历打印。
数组的内存管理
了解数组在内存中的存储方式对于编写高效的 Java 代码非常重要。
一维数组的内存布局
当声明并初始化一个一维数组时，例如 int[] numbers = {1, 2, 3, 4, 5};，数组变量 numbers 存储在栈内存中，而数组的实际元素存储在堆内存中。栈中的数组变量指向堆中数组的起始地址。
多维数组的内存布局
对于二维数组，例如 int[][] matrix = { {1, 2, 3}, {4, 5, 6} };，栈内存中的 matrix 变量指向堆内存中一个包含两个元素的数组，这两个元素分别是指向另外两个包含整数元素数组的引用。也就是说，二维数组在内存中是一种嵌套的结构，每一个维度都有其对应的数组对象。
在使用数组时，需要注意内存的释放。由于 Java 有垃圾回收机制，当数组不再被引用时，垃圾回收器会自动回收数组所占用的内存。但如果在代码中存在对数组的不必要引用，可能会导致数组无法及时被回收，从而造成内存泄漏。
数组的性能分析
数组在 Java 中的性能表现主要体现在访问速度和内存占用上。
访问速度
由于数组在内存中是连续存储的，通过索引访问数组元素的时间复杂度为 O(1)，这使得数组在随机访问方面具有很高的效率。相比之下，链表等数据结构在随机访问时需要遍历链表节点，时间复杂度为 O(n)。
内存占用
数组的内存占用相对固定，其大小在创建时就被确定。如果数组中元素数量较少，而分配的内存过大，可能会造成内存浪费。另外，多维数组的内存布局相对复杂，需要更多的内存来存储数组之间的引用关系。
在实际应用中，需要根据具体需求来选择合适的数据结构。如果需要频繁进行随机访问，数组是一个很好的选择；如果需要频繁进行插入和删除操作，链表等动态数据结构可能更合适。
数组的常见错误与解决方法
数组越界错误
如前文所述，访问数组元素时使用超出有效范围的索引会抛出 ArrayIndexOutOfBoundsException 异常。要避免这种错误，在访问数组元素之前，一定要确保索引在有效范围内。在遍历数组时，使用 array.length 来控制循环边界是一个很好的习惯。
空指针异常
当使用未初始化的数组（即数组变量的值为 null）时，会抛出 NullPointerException 异常。在使用数组之前，一定要确保数组已经正确初始化。
浅拷贝与深拷贝问题
对于多维数组，在进行复制操作时，如果使用 clone() 方法或某些默认的复制方式，可能会导致浅拷贝问题。即只复制了外层数组的引用，内层数组仍然共享。如果需要真正的深拷贝，需要手动遍历并复制每一个元素。
总结
数组是 Java 编程中非常重要的数据结构，它提供了一种高效的方式来存储和访问相同类型的数据。掌握数组的声明、初始化、访问、操作以及内存管理等方面的知识，对于编写高效、稳定的 Java 程序至关重要。在实际应用中，要根据具体需求合理选择数组的类型和使用方式，并注意避免常见的错误。通过不断的实践和优化，能够更好地发挥数组在 Java 编程中的作用。