Java多维数组 #

一、多维数组概述 #

多维数组是数组的数组，最常用的是二维数组。Java中多维数组可以是不规则的。

二、二维数组 #

2.1 声明 #

java

// 推荐方式
int[][] arr1;

// 不推荐方式
int arr2[][];
int[] arr3[];

2.2 创建 #

java

// 方式1：指定行和列
int[][] arr1 = new int[3][4];  // 3行4列

// 方式2：只指定行数
int[][] arr2 = new int[3][];   // 3行，列数待定

// 方式3：静态初始化
int[][] arr3 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

2.3 访问元素 #

java

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 访问元素
System.out.println(arr[0][0]);  // 1
System.out.println(arr[1][2]);  // 6

// 修改元素
arr[0][0] = 100;

2.4 获取长度 #

java

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

System.out.println(arr.length);      // 3（行数）
System.out.println(arr[0].length);   // 3（第0行列数）
System.out.println(arr[1].length);   // 3（第1行列数）

三、二维数组遍历 #

3.1 双重for循环 #

java

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] + " ");
    }
    System.out.println();
}

3.2 增强for循环 #

java

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int[] row : arr) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

3.3 使用Arrays.deepToString #

java

import java.util.Arrays;

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

System.out.println(Arrays.deepToString(arr));
// [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

四、不规则数组 #

4.1 创建不规则数组 #

java

// 每行列数不同
int[][] arr = new int[3][];
arr[0] = new int[1];   // 第0行1列
arr[1] = new int[2];   // 第1行2列
arr[2] = new int[3];   // 第2行3列

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

4.2 遍历不规则数组 #

java

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

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();
}

五、二维数组应用 #

5.1 矩阵运算 #

java

public class Matrix {
    // 矩阵加法
    public static int[][] add(int[][] a, int[][] b) {
        int rows = a.length;
        int cols = a[0].length;
        int[][] result = new int[rows][cols];
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                result[i][j] = a[i][j] + b[i][j];
            }
        }
        return result;
    }
    
    // 矩阵乘法
    public static int[][] multiply(int[][] a, int[][] b) {
        int rows = a.length;
        int cols = b[0].length;
        int common = a[0].length;
        int[][] result = new int[rows][cols];
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                for (int k = 0; k < common; k++) {
                    result[i][j] += a[i][k] * b[k][j];
                }
            }
        }
        return result;
    }
}

5.2 杨辉三角 #

java

public static void printYanghui(int n) {
    int[][] arr = new int[n][];
    
    for (int i = 0; i < n; i++) {
        arr[i] = new int[i + 1];
        arr[i][0] = 1;
        arr[i][i] = 1;
        
        for (int j = 1; j < i; j++) {
            arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
        }
    }
    
    for (int[] row : arr) {
        for (int num : row) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

5.3 棋盘游戏 #

java

public class ChessBoard {
    private int[][] board = new int[8][8];
    
    public void init() {
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                board[i][j] = 0;
            }
        }
    }
    
    public void placePiece(int row, int col, int piece) {
        board[row][col] = piece;
    }
    
    public void print() {
        for (int[] row : board) {
            for (int cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }
    }
}

六、三维数组 #

6.1 创建三维数组 #

java

// 创建三维数组
int[][][] arr = new int[2][3][4];

// 静态初始化
int[][][] arr2 = {
    {
        {1, 2, 3},
        {4, 5, 6}
    },
    {
        {7, 8, 9},
        {10, 11, 12}
    }
};

6.2 遍历三维数组 #

java

int[][][] arr = {
    {
        {1, 2, 3},
        {4, 5, 6}
    },
    {
        {7, 8, 9},
        {10, 11, 12}
    }
};

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

七、数组内存分析 #

7.1 二维数组内存结构 #

java

int[][] arr = new int[3][2];

// 栈内存：存储arr引用
// 堆内存：
//   - arr[0] → int[2] {0, 0}
//   - arr[1] → int[2] {0, 0}
//   - arr[2] → int[2] {0, 0}

7.2 不规则数组内存 #

java

int[][] arr = new int[3][];
arr[0] = new int[1];
arr[1] = new int[2];
arr[2] = new int[3];

// 每行指向不同长度的数组

八、常见操作 #

8.1 查找元素 #

java

public static boolean contains(int[][] arr, int target) {
    for (int[] row : arr) {
        for (int num : row) {
            if (num == target) {
                return true;
            }
        }
    }
    return false;
}

8.2 求和 #

java

public static int sum(int[][] arr) {
    int total = 0;
    for (int[] row : arr) {
        for (int num : row) {
            total += num;
        }
    }
    return total;
}

8.3 转置矩阵 #

java

public static int[][] transpose(int[][] matrix) {
    int rows = matrix.length;
    int cols = matrix[0].length;
    int[][] result = new int[cols][rows];
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            result[j][i] = matrix[i][j];
        }
    }
    return result;
}

九、注意事项 #

9.1 空指针检查 #

java

int[][] arr = new int[3][];

// arr[0]是null
// arr[0].length;  // NullPointerException

// 安全检查
if (arr[0] != null) {
    System.out.println(arr[0].length);
}

9.2 索引越界 #

java

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

// arr[0][3];  // ArrayIndexOutOfBoundsException
// arr[2][0];  // ArrayIndexOutOfBoundsException

十、总结 #

操作	语法
声明	`int[][] arr;`
创建	`arr = new int[3][4];`
初始化	`int[][] arr = {{1,2},{3,4}};`
访问	`arr[i][j]`
行数	`arr.length`
列数	`arr[i].length`

多维数组要点：

本质是数组的数组
可以是不规则数组
使用双重循环遍历
注意空指针和越界异常