在Java编程中，数组是一种非常基础且重要的数据结构，它允许我们存储固定大小的同类型元素集合。无论是初学者还是有经验的开发者，掌握数组的正确声明和使用方法都是必不可少的。本文将全面介绍Java数组的声明、初始化、访问以及常见错误陷阱，帮助你从基础到进阶全面理解数组的使用。
1. 数组的基本概念
数组是一种引用数据类型，用于存储多个相同类型的数据。数组中的元素可以通过索引访问，索引从0开始。数组的长度在创建时确定，一旦创建，长度不可改变。
1.1 数组的特点
固定大小
：数组一旦创建，其长度不可改变。
同类型元素
：数组中的所有元素必须是相同类型。
索引访问
：通过索引（从0开始）访问数组元素。
引用类型
：数组是引用类型，存储在堆内存中。
2. 数组的声明
Java中声明数组有两种主要方式：一种是使用方括号跟在数据类型后面，另一种是使用方括号跟在变量名后面。这两种方式在功能上是等价的，但第一种更常见。
2.1 声明数组的语法
// 方式一：数据类型后加方括号
数据类型[] 数组名;
// 方式二：变量名后加方括号
数据类型 数组名[];
2.2 示例代码
// 声明一个整型数组
int[] intArray;
// 声明一个字符串数组
String[] stringArray;
// 第二种方式（不推荐）
double doubleArray[];
2.3 注意事项
推荐使用第一种方式，因为更清晰地表明这是一个数组类型。
声明数组时不会分配内存空间，只是创建了一个引用。
3. 数组的初始化
数组初始化分为静态初始化和动态初始化两种方式。
3.1 静态初始化
静态初始化是指在声明数组的同时直接指定数组的元素内容，系统会自动推断数组的长度。
3.1.1 语法
数据类型[] 数组名 = {元素1, 元素2, 元素3, …};
3.1.2 示例代码
// 静态初始化整型数组
int[] numbers = {1, 2, 3, 4, 5};
// 静态初始化字符串数组
String[] names = {“Alice”, “Bob”, “Charlie”};
// 静态初始化double数组
double[] prices = {19.99, 29.99, 39.99};
3.1.3 注意事项
静态初始化必须在声明的同一行完成，不能分开写。
不能同时使用静态初始化和动态初始化（即不能同时指定长度和元素）。
3.2 动态初始化
动态初始化是指在声明数组时指定数组的长度，然后系统会为数组元素赋予默认值。
3.2.1 语法
数据类型[] 数组名 = new 数据类型[长度];
3.2.2 示例代码
// 动态初始化整型数组，长度为5
int[] intArray = new int[5];
// 动态初始化字符串数组，长度为3
String[] stringArray = new String[3];
// 动态初始化double数组，长度为10
double[] doubleArray = new double[10];
3.2.3 默认值
整型（byte, short, int, long）：0
浮点型（float, double）：0.0
字符型（char）：’\u0000’
布尔型（boolean）：false
引用类型（String, Object等）：null
3.3 两种初始化方式的对比
特点
静态初始化
动态初始化
语法
int[] arr = {1,2,3};
int[] arr = new int[3];
何时使用
已知所有元素值
未知元素值但知长度
长度
由元素个数决定
显式指定
默认值
直接指定
系统赋予默认值
4. 数组的访问和操作
4.1 访问数组元素
通过索引访问数组元素，索引从0开始。
int[] numbers = {10, 20, 30, 40, 50};
// 访问第一个元素
int first = numbers[0]; // 10
// 访问第三个元素
int third = numbers[2]; // 30
// 修改数组元素
numbers[1] = 25; // 将第二个元素改为25
4.2 获取数组长度
数组有一个
length
属性，可以获取数组的长度。
int[] numbers = new int[10];
System.out.println(“数组长度: ” + numbers.length); // 输出: 10
4.3 遍历数组
4.3.1 使用for循环
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) { System.out.println("元素[" + i + "]: " + numbers[i]); } 4.3.2 使用增强for循环（for-each） int[] numbers = {1, 2, 3, 4, 5}; for (int num : numbers) { System.out.println(num); } 4.4 数组作为方法参数 数组可以作为方法的参数传递，也可以作为方法的返回值。 4.4.1 传递数组给方法 public class ArrayExample { // 计算数组元素的总和 public static int sum(int[] arr) { int total = 0; for (int num : arr) { total += num; } return total; } public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; int result = sum(numbers); System.out.println("总和: " + result); // 输出: 15 } } 4.4.2 方法返回数组 public class ArrayExample { // 创建并返回一个数组 public static int[] createArray(int size) { int[] arr = new int[size]; for (int i = 0; i < size; i++) { arr[i] = i * 10; } return arr; } public static void main(String[] args) { int[] myArray = createArray(5); for (int num : myArray) { System.out.print(num + " "); // 输出: 0 10 20 30 40 } } } 5. 多维数组 Java支持多维数组，最常见的是二维数组。 5.1 二维数组的声明和初始化 5.1.1 静态初始化 int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; 5.1.2 动态初始化 // 方式一：规则二维数组 int[][] matrix = new int[3][4]; // 3行4列 // 方式二：不规则二维数组 int[][] jaggedArray = new int[3][]; jaggedArray[0] = new int[2]; jaggedArray[1] = new int[3]; jaggedArray[2] = new int[4]; 5.2 访问二维数组 int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; // 访问特定元素 int element = matrix[1][2]; // 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(); } 6. 数组工具类Arrays Java提供了一个非常有用的工具类 java.util.Arrays ，提供了许多操作数组的静态方法。 6.1 常用方法 6.1.1 toString() - 将数组转换为字符串 import java.util.Arrays; int[] numbers = {1, 2, 3, 4, 5}; String str = Arrays.toString(numbers); System.out.println(str); // 输出: [1, 2, 3, 4, 5] 6.1.2 sort() - 数组排序 import java.util.Arrays; int[] numbers = {5, 2, 8, 1, 3}; Arrays.sort(numbers); System.out.println(Arrays.toString(numbers)); // 输出: [1, 2, 3, 5, 8] 6.1.3 binarySearch() - 二分查找 import java.util.Arrays; int[] numbers = {1, 2, 3, 4, 5}; int index = Arrays.binarySearch(numbers, 3); System.out.println("3的索引: " + index); // 输出: 2 6.1.4 copyOf() - 复制数组 import java.util.Arrays; int[] original = {1, 2, 3, 4, 5}; int[] copy = Arrays.copyOf(original, 3); System.out.println(Arrays.toString(copy)); // 输出: [1, 2, 3] 6.1.5 fill() - 填充数组 import java.util.Arrays; int[] numbers = new int[5]; Arrays.fill(numbers, 10); System.out.println(Arrays.toString(numbers)); // 输出: [10, 10, 10, 10, 10] 7. 常见错误和陷阱 7.1 数组越界异常 int[] arr = new int[5]; // 错误：索引超出范围 // arr[5] = 10; // 抛出ArrayIndexOutOfBoundsException 7.2 空指针异常 int[] arr = null; // 错误：数组未初始化 // System.out.println(arr.length); // 抛出NullPointerException 7.3 未初始化数组 // 错误：声明但未初始化 int[] arr; // System.out.println(arr.length); // 抛出NullPointerException 7.4 错误的初始化方式 // 错误：静态初始化不能分开写 int[] arr; arr = {1, 2, 3}; // 编译错误 // 正确写法 int[] arr = {1, 2, 3}; // 或者 int[] arr; arr = new int[]{1, 2, 3}; 7.5 数组长度不可变 int[] arr = new int[5]; // 错误：不能改变数组长度 // arr.length = 10; // 编译错误 8. 数组的最佳实践 8.1 使用增强for循环 当不需要索引时，优先使用增强for循环，代码更简洁。 // 推荐 for (int num : numbers) { System.out.println(num); } // 不推荐（除非需要索引） for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } 8.2 检查数组边界 在访问数组元素前，确保索引在有效范围内。 public static safeAccess(int[] arr, int index) { if (index >= 0 && index < arr.length) { return arr[index]; } else { return -1; // 或抛出异常 } } 8.3 使用Arrays工具类 尽量使用 Arrays 类提供的方法，而不是自己实现，因为这些方法经过优化且经过充分测试。 8.4 避免魔法数字 使用 length 属性而不是硬编码数组长度。 // 推荐 for (int i = 0; i < arr.length; i++) { // ... } // 不推荐 for (int i = 0; i < 5; i++) { // ... } 9. 高级主题：数组与内存 9.1 数组在内存中的存储 数组是引用类型，存储在堆内存中。数组变量存储的是数组对象的引用（地址）。 int[] arr1 = {1, 2, 3}; int[] arr2 = arr1; // arr2和arr1指向同一个数组对象 arr2[0] = 100; System.out.println(arr1[0]); // 输出: 100 9.2 数组的默认值 动态初始化的数组元素会被赋予默认值： int[] intArr = new int[3]; System.out.println(Arrays.toString(intArr)); // [0, 0, 0] String[] strArr = new String[3]; System.out.println(Arrays.toString(strArr)); // [null, null, null] 10. 总结 数组是Java编程中不可或缺的数据结构。掌握数组的声明、初始化、访问和操作是每个Java开发者的基本功。通过本文的详细讲解和示例代码，你应该能够： 正确声明数组 使用静态和动态初始化数组 访问和修改数组元素 遍历数组 使用Arrays工具类 避免常见的数组错误 记住，数组虽然简单，但在实际开发中应用广泛。多加练习，熟练掌握数组的各种操作，将为学习更复杂的数据结构和算法打下坚实的基础。