在 Java 中，数组（Array）是用于存储多个相同类型数据的容器。数组的大小在创建时固定，且一旦定义了数组，数组的长度就无法更改。数组在 Java 中是一种对象，虽然它存储的是基本数据类型或对象的引用。

1. 数组的声明与创建

1.1 声明数组

数组的声明有两种方式，分别是：

• 先声明数组，再为其分配内存。
• 声明数组并同时初始化。

// 第一种方式：先声明，再分配内存
int[] arr1;
arr1 = new int[5];  // 创建一个长度为 5 的整数数组

// 第二种方式：声明时直接分配内存并初始化
int[] arr2 = new int[5];  // 创建一个长度为 5 的整数数组，默认值为 0

// 另一种方式：声明时直接初始化数组元素
int[] arr3 = {1, 2, 3, 4, 5};  // 创建并初始化一个数组

1.2 数组的大小

数组的大小一旦创建就不能改变，因此在声明时需要知道要存储多少元素。

int[] arr = new int[10];  // 创建一个长度为 10 的整数数组

2. 数组的初始化

Java 数组会根据数据类型的不同提供默认值：

• 对于基本数据类型：
• int 默认值为 0
• double 默认值为 0.0
• char 默认值为 '\u0000'（空字符）
• boolean 默认值为 false
• 对于对象类型：
• 默认值为 null

int[] arr = new int[3];  // 数组元素默认初始化为 0
System.out.println(arr[0]);  // 输出 0

3. 数组的访问

数组中的元素可以通过索引（从 0 开始）来访问和修改。

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr[0]);  // 输出 1
arr[1] = 10;  // 修改第二个元素为 10
System.out.println(arr[1]);  // 输出 10

4. 数组的遍历

数组遍历是通过循环语句来访问数组中的每个元素。常用的方式有：

4.1 使用 for 循环

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

4.2 使用增强 for 循环（for-each）

增强 for 循环是遍历数组的简洁方式：

int[] arr = {1, 2, 3, 4, 5};
for (int num : arr) {
    System.out.println(num);  // 输出 1, 2, 3, 4, 5
}

5. 数组的常用方法

• length：返回数组的长度。

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr.length);  // 输出 5

• Arrays.toString()：将数组转换为字符串。

import java.util.Arrays;
int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));  // 输出 [1, 2, 3, 4, 5]

• Arrays.sort()：对数组进行排序。

import java.util.Arrays;
int[] arr = {5, 3, 1, 4, 2};
Arrays.sort(arr);  // 排序
System.out.println(Arrays.toString(arr));  // 输出 [1, 2, 3, 4, 5]

6. 多维数组

Java 支持多维数组，最常见的是二维数组。

6.1 声明和初始化二维数组

// 声明二维数组并初始化
int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 或者先声明，再分配内存
int[][] arr2 = new int[3][3];  // 3 行 3 列的二维数组

6.2 访问二维数组的元素

通过行和列的索引访问二维数组中的元素。

System.out.println(arr[0][1]);  // 输出 2
arr[1][1] = 10;  // 修改第二行第二列的元素为 10
System.out.println(arr[1][1]);  // 输出 10

6.3 遍历二维数组

可以通过嵌套的 for 循环遍历二维数组。

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");  // 输出 1 2 3 4 5 6 7 8 9
    }
    System.out.println();
}

7. 数组的注意事项

• 数组越界：如果访问数组时，索引超出了数组的范围，Java 会抛出 ArrayIndexOutOfBoundsException 异常。

  int[] arr = {1, 2, 3};
  System.out.println(arr[3]);  // 抛出 ArrayIndexOutOfBoundsException

• 数组是对象：虽然数组在声明时似乎是一个基本数据类型（如 int[]），但它实际上是一个对象。

  int[] arr = new int[5];
  System.out.println(arr instanceof Object);  // 输出 true

8. 数组与性能

• 固定大小：数组的大小是固定的，一旦分配就无法改变。可以通过创建新数组并复制元素来扩展数组，但这会增加时间和空间的开销。
• 效率：数组的元素存储是连续的，因此通过索引访问数组元素非常高效，时间复杂度为 O(1)。

9. 示例代码：数组的常用操作

import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        // 声明并初始化数组
        int[] arr = {5, 3, 8, 1, 2};

        // 获取数组长度
        System.out.println("数组长度: " + arr.length);

        // 遍历数组
        System.out.println("数组元素：");
        for (int num : arr) {
            System.out.print(num + " ");  // 输出：5 3 8 1 2
        }

        // 使用 Arrays.toString() 输出数组
        System.out.println("\n使用 Arrays.toString() 输出数组: " + Arrays.toString(arr));

        // 排序数组
        Arrays.sort(arr);
        System.out.println("排序后的数组：" + Arrays.toString(arr));  // 输出：[1, 2, 3, 5, 8]

        // 二维数组示例
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // 打印二维数组
        System.out.println("二维数组：");
        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();
        }
    }
}

输出：

数组长度: 5
数组元素：
5 3 8 1 2 
使用 Arrays.toString() 输出数组: [5, 3, 8, 1, 2]
排序后的数组：[1, 2, 3, 5, 8]
二维数组：
1 2 3 
4 5 6 
7 8 9 

10. 总结

• 数组的基本特性：Java 中的数组是固定大小的对象，存储相同类型的元素。
• 数组的访问方式：通过索引来访问数组元素，数组的索引从 0 开始。
• 数组的操作：可以使用常规的 for 循环或增强的 for 循环遍历数组，Java 提供了许多 Arrays 工

具类方法来简化数组的处理。

• 多维数组：可以使用多维数组（如二维数组）存储和处理数据。

数组是 Java 编程中非常基础且高效的容器类型，适用于许多场景，尤其是在处理大量相同类型数据时。

更多详细内容，请关注其他相关文章！