Java 数组

数组(Array)是 Java 最基础的容器——存一组同类型数据,长度固定。虽然实际项目里更多用 ArrayList,但理解数组是学集合、字符串、算法的前提。本章带你完整掌握 Java 数组。

1. 一维数组声明与初始化

Java 数组有两种初始化方式:静态初始化(声明时直接给值)和动态初始化(指定长度,默认值填充)。

public class ArrayDeclare {
    public static void main(String[] args) {
        // 1. 静态初始化:声明时直接给值
        int[] a = {1, 2, 3, 4, 5};
        int[] b = new int[]{10, 20, 30};     // 完整写法

        // 2. 动态初始化:指定长度,默认值填充(int 默认 0)
        int[] c = new int[5];                 // {0, 0, 0, 0, 0}
        c[0] = 100;
        c[1] = 200;

        // 3. 也可以写老式 C 风格(不推荐)
        // int d[] = {1, 2, 3};    // 中括号跟在变量后,可读性差

        // 数组长度:arr.length(属性,不是方法!)
        System.out.println(a.length);    // 5

        // 访问元素:索引从 0 开始
        System.out.println(a[0]);        // 1
        System.out.println(a[4]);        // 5
        // System.out.println(a[5]);     // ❌ ArrayIndexOutOfBoundsException
    }
}

几个要点:

• 声明推荐 int[] arr(中括号跟类型),不推荐 int arr[](C 风格,可读性差)。
• 数组长度固定:new int[5] 创建后长度就不能改。要动态扩容用 ArrayList。
• arr.length 是属性(没有括号),不是方法!
• 索引从 0 开始,越界访问会抛 ArrayIndexOutOfBoundsException。
• 动态初始化的默认值:int 是 0、boolean 是 false、引用类型是 null。

2. 数组遍历

有三种方式遍历数组:

public class ArrayIterate {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40, 50};

        // 1. 经典 for:能拿到索引
        for (int i = 0; i < nums.length; i++) {
            System.out.println("nums[" + i + "] = " + nums[i]);
        }

        // 2. 增强 for(foreach):简洁,但不能拿索引
        int sum = 0;
        for (int n : nums) {
            sum += n;
        }
        System.out.println("sum = " + sum);    // 150

        // 3. Java 8+ Stream:函数式风格
        // Arrays.stream(nums).forEach(System.out::println);
    }
}

• 经典 for:需要索引时用,能修改元素。
• 增强 for(foreach):只遍历不关心索引时用,最简洁。
• Stream:Java 8 函数式风格,适合链式过滤、统计。

3. 二维数组

二维数组本质是"数组的数组"——每个元素又是一个一维数组。常用于矩阵、棋盘、表格:

public class Array2D {
    public static void main(String[] args) {
        // 1. 静态初始化 2D 数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // 2. 动态初始化:3 行 4 列
        int[][] grid = new int[3][4];        // 默认全 0

        // 访问:arr[行][列]
        System.out.println(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();
        }
        // 输出:
        // 1 2 3
        // 4 5 6
        // 7 8 9

        // 3. 不规则数组(每行列数不同,Java 支持)
        int[][] ragged = new int[3][];
        ragged[0] = new int[]{1};
        ragged[1] = new int[]{2, 3};
        ragged[2] = new int[]{4, 5, 6};
    }
}

Java 还支持不规则数组(每行列数不同),因为二维数组本质是"一维数组的引用数组"。

4. Arrays 工具类(超常用)

Java 提供 java.util.Arrays 工具类,封装了数组常用操作:排序、查找、打印、复制、比较。日常开发几乎绕不开。

import java.util.Arrays;

public class ArraysToolDemo {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9, 3};

        // 1. 把数组转成可读字符串(调试最常用)
        System.out.println(Arrays.toString(nums));   // [5, 2, 8, 1, 9, 3]

        // 2. 排序(原地排序,改原数组)
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));   // [1, 2, 3, 5, 8, 9]

        // 3. 二分查找(必须先排序!)
        int idx = Arrays.binarySearch(nums, 5);
        System.out.println("5 的索引: " + idx);     // 3

        // 4. 把数组全部填充为某值
        int[] arr = new int[5];
        Arrays.fill(arr, 100);
        System.out.println(Arrays.toString(arr));   // [100, 100, 100, 100, 100]

        // 5. 复制数组
        int[] copy = Arrays.copyOf(nums, 3);        // 只取前 3 个
        System.out.println(Arrays.toString(copy));  // [1, 2, 3]

        // 6. 比较两个数组内容是否相同
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println(a == b);                 // false(比较地址)
        System.out.println(Arrays.equals(a, b));    // true(比较内容)
    }
}

新手最该熟练的两个:

• Arrays.toString(arr):把数组转成 [1, 2, 3] 形式——调试时直接 System.out.println(arr) 会打出奇怪的地址([I@hashcode),一定要用 Arrays.toString。
• Arrays.sort(arr):快速排序,O(n log n)。注意是原地排序,会修改原数组!

二维数组打印用 Arrays.deepToString(matrix)。

5. 数组作为方法参数与返回值

数组是引用类型,可以作方法参数和返回值:

import java.util.Arrays;

public class ArrayReturn {
    // 方法可以返回数组
    public static int[] reverse(int[] arr) {
        int[] result = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            result[i] = arr[arr.length - 1 - i];
        }
        return result;
    }

    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};
        int[] reversed = reverse(original);
        System.out.println(Arrays.toString(reversed));    // [5, 4, 3, 2, 1]
        // 原数组不变
        System.out.println(Arrays.toString(original));    // [1, 2, 3, 4, 5]
    }
}

记住数组作参数传的是地址——方法内部修改元素会影响外部。但若方法内重新给参数赋值(arr = new int[]{...}),外部不受影响(因为只改了形参的指向)。

6. 数组 vs ArrayList,选哪个?

原则:长度已知且不变用数组(性能更好);长度可变或需要丰富操作用 ArrayList。日常业务 ArrayList 居多。

小结

这一章你掌握了 Java 数组:声明、初始化、遍历、二维数组、Arrays 工具类。下一篇我们看 Java 中用得最多的引用类型——字符串 String,以及它的可变兄弟 StringBuilder。

← 上一篇 Java 方法

下一篇 Java 字符串 →