Java 中的多维数组本质是数组的数组，最常用的是二维数组（比如表格、矩阵），三维及以上极少用到，本文重点讲二维数组的定义、使用、遍历和实战，所有代码可直接复制运行，零基础也能看懂。

核心概念

二维数组可以理解为一行行的一维数组组成的大数组，比如一个 3 行 2 列的表格，行和列的下标都从 0 开始，长度固定（和一维数组一样，定义后不能修改行 / 列长度）。

一、二维数组的 3 种定义方式（必记，第 1/2 种最常用）

以 int 类型二维数组为例，其他类型（String/double）直接替换类型即可。

java

运行

public class TwoDArrayDefine {
    public static void main(String[] args) {
        // 方式1：指定行和列的长度（最常用），默认值为0（数值型）/null（引用型）
        // 3行2列的二维数组：3个一维数组，每个一维数组有2个元素
        int[][] arr1 = new int[3][2];

        // 方式2：声明+直接赋值（初始化时确定元素，无需指定长度）
        int[][] arr2 = {{1,2}, {3,4}, {5,6}}; // 3行2列

        // 方式3：不规则二维数组（行定长，列不定长）→ 重点实用场景
        // 先指定3行，列的长度后续单独赋值（每行可以是不同长度的一维数组）
        int[][] arr3 = new int[3][];
        arr3[0] = new int[2]; // 第0行：2列
        arr3[1] = new int[3]; // 第1行：3列
        arr3[2] = new int[1]; // 第2行：1列
    }
}

💡 关键：不规则二维数组是实际开发中高频场景（比如每行数据个数不同），也是多维数组的灵活用法。

二、二维数组核心操作：访问 / 修改元素

通过行下标 + 列下标操作，格式：数组名[行索引][列索引]，结合数组长度属性：

• arr.length：获取行数
• arr[i].length：获取第 i 行的列数

java

运行

public class TwoDArrayUse {
    public static void main(String[] args) {
        int[][] arr = {{1,2}, {3,4}, {5,6}}; // 3行2列

        // 1. 访问元素：取第1行第0列（下标从0开始）→ 结果：3
        System.out.println(arr[1][0]);

        // 2. 修改元素：把第2行第1列改为99 → 原数组变为{{1,2},{3,4},{5,99}}
        arr[2][1] = 99;
        System.out.println(arr[2][1]); // 99

        // 3. 获取长度：行数、指定行的列数
        System.out.println("行数：" + arr.length); // 3
        System.out.println("第0行的列数：" + arr[0].length); // 2
    }
}

三、二维数组的 2 种遍历方式（开发必用，全覆盖）

遍历即逐个取出所有元素，分普通 for 循环（可操作下标，推荐）和增强 for 循环（简洁，无需下标），适配规则二维数组和不规则二维数组。

方式 1：普通 for 循环（双层循环，行循环 + 列循环）

最灵活，能获取行 / 列下标，支持修改元素，不规则数组也能正常遍历。

java

运行

public class TwoDArrayFor {
    public static void main(String[] args) {
        // 定义不规则二维数组（3行，列数分别为2、3、1）
        int[][] arr = new int[3][];
        arr[0] = new int[]{1,2};
        arr[1] = new int[]{3,4,5};
        arr[2] = new int[]{6};

        // 外层循环：遍历行
        for (int i = 0; i < arr.length; i++) {
            // 内层循环：遍历第i行的列（用arr[i].length适配列数）
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " "); // 按行打印元素
            }
            System.out.println(); // 换行，更贴合表格格式
        }
    }
}

运行结果（自动适配列数，无下标越界）：

plaintext

1 2 
3 4 5 
6 

方式 2：增强 for 循环（双层，简洁易写）

无需关注下标，适合仅读取元素的场景，规则 / 不规则数组都适用。

java

运行

public class TwoDArrayForEach {
    public static void main(String[] args) {
        int[][] arr = {{1,2}, {3,4}, {5,6}};

        // 外层：遍历每一行（row是每一行的一维数组）
        for (int[] row : arr) {
            // 内层：遍历当前行的每个元素
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

运行结果：

plaintext

1 2 
3 4 
5 6 

四、常见多维数组类型实操（String/double）

直接替换类型，用法和 int 二维数组完全一致，重点看 String 二维数组（开发中常用作存储表格数据）。

java

运行

public class TwoDArrayOtherType {
    public static void main(String[] args) {
        // 1. String二维数组：存储学生姓名+成绩（3行2列）
        String[][] students = {{"张三", "90"}, {"李四", "85"}, {"王五", "95"}};
        System.out.println(students[0][0] + "的成绩：" + students[0][1]); // 张三的成绩：90

        // 2. double二维数组：存储矩阵数据
        double[][] matrix = {{1.1, 2.2}, {3.3, 4.4}};
        System.out.println(matrix[1][1]); // 4.4
    }
}

五、二维数组高频实战案例（直接复制用）

案例 1：求二维数组所有元素的总和

java

运行

public class TwoDArraySum {
    public static void main(String[] args) {
        int[][] arr = {{1,2}, {3,4}, {5,6}};
        int sum = 0;
        for (int[] row : arr) {
            for (int num : row) {
                sum += num;
            }
        }
        System.out.println("数组总和：" + sum); // 21
    }
}

案例 2：求二维数组的最大值

java

运行

public class TwoDArrayMax {
    public static void main(String[] args) {
        int[][] arr = {{3, 8}, {5, 2}, {9, 4}};
        int max = arr[0][0]; // 初始化最大值为第一个元素
        for (int[] row : arr) {
            for (int num : row) {
                if (num > max) {
                    max = num;
                }
            }
        }
        System.out.println("数组最大值：" + max); // 9
    }
}

案例 3：二维数组转表格打印（格式化，更直观）

java

运行

public class TwoDArrayPrint {
    public static void main(String[] args) {
        // 学生信息：姓名、年龄、成绩
        String[][] stuInfo = {{"姓名", "年龄", "成绩"}, {"张三", "20", "90"}, {"李四", "19", "85"}};
        // 双层循环格式化打印，每个元素占8个字符，左对齐
        for (String[] row : stuInfo) {
            for (String info : row) {
                System.out.printf("%-8s", info);
            }
            System.out.println();
        }
    }
}

运行结果（规整的表格格式）：

plaintext

姓名      年龄      成绩      
张三      20        90        
李四      19        85        

六、三维数组（了解即可，几乎不用）

三维数组是二维数组的数组，可以理解为「多个表格组成的集合」，定义和遍历只需三层循环，用法和二维数组一致。

java

运行

public class ThreeDArray {
    public static void main(String[] args) {
        // 定义3个二维数组（每个二维数组2行2列）
        int[][][] arr = {{{1,2}, {3,4}}, {{5,6}, {7,8}}, {{9,10}, {11,12}}};
        
        // 三层增强for循环遍历
        for (int[][] twoD : arr) {
            for (int[] row : twoD) {
                for (int num : row) {
                    System.out.print(num + " ");
                }
                System.out.println();
            }
            System.out.println("-----"); // 分隔每个二维数组
        }
    }
}

七、多维数组常见坑（避坑必看）

1. 下标越界异常（ArrayIndexOutOfBoundsException）原因：行 / 列下标超过arr.length-1/arr[i].length-1，比如 3 行数组访问arr[3][0]。解决：用arr.length和arr[i].length做循环条件，避免硬编码数字。

2. 空指针异常（NullPointerException）原因：定义不规则数组时，未初始化行就访问列，比如int[][] arr = new int[3][]; arr[0][0] = 1;（arr [0] 未初始化）。解决：先给每行赋值arr[i] = new int[列数]，再操作列元素。

3. 误以为多维数组是 “矩形”误区：必须行和列长度一致，实际支持不规则数组（每行列数不同），这是 Java 多维数组的灵活特性。

八、核心知识点总结（一分钟记牢）

1. 多维数组本质是数组的数组，开发中只用二维数组，三维及以上几乎不用；
2. 二维数组定义：指定行列 / 直接赋值 / 不规则（行定列不定），后两种更常用；
3. 元素操作：arr[行索引][列索引]，下标从0开始；
4. 长度获取：arr.length（行数）、arr[i].length（第 i 行列数）；
5. 遍历方式：双层普通 for 循环（可操作下标，推荐）、双层增强 for 循环（简洁）；
6. 核心场景：存储表格数据、矩阵运算、不规则行数据（比如不同行的字段数不同）。