Java 多维数组

学习目标

理解多维数组的概念与内存模型
掌握二维、三维数组的声明、初始化与访问方式
能够处理规则与不规则（锯齿形）多维数组
熟练使用嵌套循环遍历多维数组
了解多维数组在实际开发中的典型应用场景

什么是多维数组？

多维数组是数组的数组，用于表示表格、矩阵或更高维度的数据结构。最常见的是二维数组（行 × 列），但 Java 支持任意维度。

// 通用形式
dataType[dim1][dim2]...[dimN] arrayName = new dataType[size1][size2]...[sizeN];

// 示例
int[][] matrix = new int[3][4];      // 3 行 4 列
int[][][] cube = new int[2][3][4];   // 2×3×4 的三维数组

总元素数 = 各维度大小的乘积
例如：new int[2][3][4] 可存储 2 × 3 × 4 = 24 个整数

二维数组

二维数组是最常用的多维数组，可视为由多个一维数组组成的数组。

1. 声明与初始化

方式一：静态初始化

已知所有值

int[][] arr = {
    {1, 2},
    {3, 4}
};

方式二：动态初始化

指定行列数

int rows = 2, cols = 2;
int[][] arr = new int[rows][cols];

方式三：逐行赋值

int[][] arr = new int[2][];
arr[0] = new int[]{1, 2};
arr[1] = new int[]{3, 4};

这种方式支持不规则数组（每行长度不同）

2. 访问元素

使用 arr[i][j] 访问第 i 行、第 j 列的元素（索引从 0 开始）：

int[][] matrix = {{10, 20}, {30, 40}};
System.out.println(matrix[1][0]); // 输出: 30

3. 遍历二维数组

使用嵌套 for 循环：

for (int i = 0; i < arr.length; i++) {           // 遍历行
    for (int j = 0; j < arr[i].length; j++) {    // 遍历列
        System.out.print(arr[i][j] + " ");
    }
    System.out.println(); // 换行
}

使用 arr[i].length 可处理不规则数组

4. 用户输入示例

import java.util.Scanner;

public class MatrixInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.print("请输入行数: ");
        int rows = sc.nextInt();
        System.out.print("请输入列数: ");
        int cols = sc.nextInt();
        
        int[][] matrix = new int[rows][cols];
        
        System.out.println("请输入矩阵元素:");
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }
        
        System.out.println("您输入的矩阵为:");
        for (int[] row : matrix) {
            for (int val : row) {
                System.out.print(val + " ");
            }
            System.out.println();
        }
        sc.close();
    }
}

三维数组

三维数组可理解为多个二维数组的集合，常用于表示立方体、时间序列矩阵等。

1. 初始化与访问

// 静态初始化
int[][][] cube = {
    { {1, 2}, {3, 4} },
    { {5, 6}, {7, 8} }
};

// 访问元素
System.out.println(cube[0][1][0]); // 输出: 3

2. 遍历三维数组

使用三层嵌套循环：

for (int i = 0; i < cube.length; i++) {
    for (int j = 0; j < cube[i].length; j++) {
        for (int k = 0; k < cube[i][j].length; k++) {
            System.out.println("cube[" + i + "][" + j + "][" + k + "] = " + cube[i][j][k]);
        }
    }
}

不规则多维数组

Java 允许每行长度不同，形成“锯齿形”数组：

int[][] jagged = new int[3][];
jagged[0] = new int[2]; // 第一行 2 个元素
jagged[1] = new int[4]; // 第二行 4 个元素
jagged[2] = new int[3]; // 第三行 3 个元素

// 安全遍历
for (int i = 0; i < jagged.length; i++) {
    for (int j = 0; j < jagged[i].length; j++) {
        jagged[i][j] = i + j;
    }
}

这是 Java 相比 C/C++ 的优势之一 —— 更灵活的内存布局

运行时动态输入与处理

以下程序演示如何在运行时读取不规则二维数组，并统计奇偶数：

import java.util.Scanner;

public class DynamicMatrix {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.print("请输入行数: ");
        int n = sc.nextInt();
        int[][] arr = new int[n][];
        
        for (int i = 0; i < n; i++) {
            System.out.print("第 " + (i+1) + " 行的列数: ");
            int m = sc.nextInt();
            arr[i] = new int[m];
            
            System.out.print("输入 " + m + " 个数字: ");
            for (int j = 0; j < m; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        
        int even = 0, odd = 0;
        System.out.println("\n输入的数组:");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
                if (arr[i][j] % 2 == 0) even++;
                else odd++;
            }
            System.out.println();
        }
        
        System.out.println("偶数: " + even + ", 奇数: " + odd);
        sc.close();
    }
}

典型应用场景

应用场景	说明
学生成绩表	行 = 学生，列 = 科目成绩
图像处理	二维像素矩阵（RGB 可用三维）
动态规划	`dp[i][j]` 表示状态转移
图论	邻接矩阵表示图的连接关系
科学计算	矩阵乘法、线性代数运算
游戏开发	棋盘、地图网格（如扫雷、俄罗斯方块）

重点总结

多维数组本质是“数组的数组”，内存非完全连续（每行连续，行间可能不连续）
二维数组：arr[i][j]，三维：arr[i][j][k]
使用 .length 获取当前维度大小：arr.length（行数），arr[0].length（第一行列数）
支持不规则数组，灵活性高
遍历必须使用嵌套循环，层数 = 维度数
越界访问会抛出 ArrayIndexOutOfBoundsException

思考题

如何创建一个 3×3 的单位矩阵（对角线为 1，其余为 0）？
在处理大型稀疏矩阵（大部分元素为 0）时，使用普通二维数组是否高效？有什么替代方案？
为什么 Java 的多维数组被称为“锯齿数组”？这与 C/C++ 的多维数组有何本质区别？