Java二维数组案例如何赋值

本文目录导读：

1. 声明时直接初始化（静态赋值）
2. 动态赋值（运行时赋值）
3. 从控制台输入赋值（Scanner）
4. 使用Arrays.fill()赋值（所有元素相同）
5. 常见错误与注意点
6. 总结速记表

在Java中，二维数组本质上是“数组的数组”，赋值方式有很多种，取决于你是声明时初始化，还是声明后动态赋值。

下面整理了最常用的几种案例，涵盖了基础、动态输入和常见陷阱。

声明时直接初始化（静态赋值）

适用于数据已知的情况。

public class ArrayDemo {
    public static void main(String[] args) {
        // 方式一：完整写法
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        // 方式二：new + 花括号（不指定行数和列数）
        int[][] matrix2 = new int[][] {
            {10, 20},
            {30, 40, 50} // 注意：这里第二行有3个元素 → 不规则数组
        };
        // 方式三：声明并分配固定大小，再赋值（零散赋值）
        int[][] grid = new int[2][3]; // 2行3列，默认所有值为0
        grid[0][0] = 100;
        grid[0][1] = 200;
        grid[1][2] = 300;
    }
}

动态赋值（运行时赋值）

情况A：固定行列，循环赋值（如九九乘法表）

public class DynamicFill {
    public static void main(String[] args) {
        int[][] table = new int[9][9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                table[i][j] = (i + 1) * (j + 1);
            }
        }
        // 打印乘法表
        for (int[] row : table) {
            for (int num : row) {
                System.out.printf("%4d", num);
            }
            System.out.println();
        }
    }
}

情况B：不规则数组（每行长度不同）

public class JaggedArray {
    public static void main(String[] args) {
        // 先分配行数
        int[][] jagged = new int[3][];
        // 再为每一行分配不同长度的列
        jagged[0] = new int[2];  // 第0行有2列
        jagged[1] = new int[4];  // 第1行有4列
        jagged[2] = new int[3];  // 第2行有3列
        // 逐个赋值
        jagged[0][0] = 11;
        jagged[0][1] = 12;
        jagged[1][0] = 21;
        jagged[1][1] = 22;
        jagged[1][2] = 23;
        jagged[1][3] = 24;
        jagged[2][0] = 31;
        jagged[2][1] = 32;
        jagged[2][2] = 33;
    }
}

从控制台输入赋值（Scanner）

import java.util.Scanner;
public class ScannerInput {
    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[][] arr = new int[rows][cols];
        System.out.println("请输入" + rows + "行" + cols + "列的整数:");
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                arr[i][j] = sc.nextInt();   // 空格或回车分隔
            }
        }
        System.out.println("你输入的二维数组是:");
        for (int[] row : arr) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
        sc.close();
    }
}

使用Arrays.fill()赋值（所有元素相同）

import java.util.Arrays;
public class FillArray {
    public static void main(String[] args) {
        int[][] arr = new int[3][4];
        // 填充每一行（注意：不能直接 fill(arr, 1) 对二维数组生效）
        for (int[] row : arr) {
            Arrays.fill(row, 1);
        }
        // 或者更直接的方法：创建时用循环
        for (int i = 0; i < arr.length; i++) {
            Arrays.fill(arr[i], 5);
        }
        // 打印检查
        for (int[] row : arr) {
            System.out.println(Arrays.toString(row));
        }
    }
}

常见错误与注意点

❌ 错误1：试图在不确定列数时访问元素

int[][] arr = new int[3][];   // 只有行，没有列
arr[0][0] = 1;                // 运行时报错：NullPointerException
// ✅ 必须先分配列：arr[0] = new int[5];

❌ 错误2：混淆行和列索引（小心下标越界）

int[][] a = new int[2][3];
// a[0][3]  错误！第0行只有0,1,2三个下标

❌ 错误3：使用 Arrays.fill() 直接填充二维数组

int[][] arr = new int[2][3];
// Arrays.fill(arr, 1);      // 编译错误（arr是int[][]类型，不是int[]）
// ✅ 应该对每一行单独 fill

总结速记表

如果你有具体的业务场景（比如学生成绩表、矩阵转置、图像灰度值等），你可以告诉我更详细的例子,我可以帮你写一个针对性更强的案例。