8.5 二维数组入门

二维数组的概念

二维数组是一种特殊的数组，它的元素是一维数组。可以将二维数组看作是一个表格，其中第一个维度表示行，第二个维度表示列。

二维数组的定义

在 Java 中，二维数组的定义有两种方式：

方式一：声明二维数组变量

数据类型[][] 数组名;

方式二：声明二维数组变量（C 风格）

数据类型 数组名[][];

示例：

// 声明整型二维数组
int[][] matrix;
// 或
int matrix[][];

// 声明字符串二维数组
String[][] names;
// 或
String names[][];

二维数组的初始化

二维数组的初始化有三种方式：静态初始化、动态初始化和默认初始化。

1. 静态初始化

静态初始化是在声明二维数组的同时为数组元素赋值。

语法：

数据类型[][] 数组名 = {
    {元素1, 元素2, 元素3, ...},
    {元素1, 元素2, 元素3, ...},
    ...
};

示例：

// 静态初始化整型二维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 静态初始化字符串二维数组
String[][] names = {
    {"Alice", "Bob"},
    {"Charlie", "David"},
    {"Eve", "Frank"}
};

2. 动态初始化

动态初始化是先声明二维数组，然后使用 new 关键字创建数组对象并指定维度。

语法：

// 方式一：指定行数和列数
数据类型[][] 数组名 = new 数据类型[行数][列数];

// 方式二：只指定行数，列数可以不同
数据类型[][] 数组名 = new 数据类型[行数][];

示例：

// 动态初始化整型二维数组，3行3列
int[][] matrix = new int[3][3];

// 动态初始化整型二维数组，只指定行数
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[2]; // 第一行有 2 列
jaggedArray[1] = new int[3]; // 第二行有 3 列
jaggedArray[2] = new int[4]; // 第三行有 4 列

3. 默认初始化

当使用动态初始化创建二维数组时，数组元素会被自动赋予默认值。

示例：

// 动态初始化整型二维数组，默认值为 0
int[][] matrix = new int[2][2];
System.out.println(matrix[0][0]); // 输出 0
System.out.println(matrix[0][1]); // 输出 0
System.out.println(matrix[1][0]); // 输出 0
System.out.println(matrix[1][1]); // 输出 0

// 动态初始化字符串二维数组，默认值为 null
String[][] names = new String[2][2];
System.out.println(names[0][0]); // 输出 null
System.out.println(names[0][1]); // 输出 null
System.out.println(names[1][0]); // 输出 null
System.out.println(names[1][1]); // 输出 null

二维数组的访问

二维数组的访问是通过行索引和列索引来实现的。

语法：

数组名[行索引][列索引]

示例：

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

// 访问元素
int element = matrix[1][2]; // 获取第二行第三列的元素，值为 6
System.out.println(element); // 输出 6

// 修改元素
matrix[0][0] = 100; // 将第一行第一列的元素修改为 100
System.out.println(matrix[0][0]); // 输出 100

二维数组的遍历

二维数组的遍历需要使用嵌套循环，外层循环遍历行，内层循环遍历列。

1. 使用嵌套 for 循环遍历

public class TwoDimensionalArrayTraversalExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 使用嵌套 for 循环遍历二维数组
        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();
        }
    }
}

2. 使用增强型 for 循环遍历

public class TwoDimensionalArrayForEachExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 使用增强型 for 循环遍历二维数组
        for (int[] row : matrix) { // 遍历行
            for (int element : row) { // 遍历列
                System.out.print(element + " ");
            }
            System.out.println();
        }
    }
}

二维数组的长度

二维数组的长度是指数组的行数，可以通过 数组名.length 来获取。每一行的长度可以通过 数组名[行索引].length 来获取。

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

System.out.println("Number of rows: " + matrix.length); // 输出 3
System.out.println("Number of columns in row 0: " + matrix[0].length); // 输出 3
System.out.println("Number of columns in row 1: " + matrix[1].length); // 输出 3

不规则二维数组

在 Java 中，二维数组的每一行可以有不同的长度，这样的数组称为不规则二维数组（也称为锯齿状数组）。

public class JaggedArrayExample {
    public static void main(String[] args) {
        // 创建不规则二维数组
        int[][] jaggedArray = new int[3][];
        jaggedArray[0] = new int[2]; // 第一行有 2 列
        jaggedArray[1] = new int[3]; // 第二行有 3 列
        jaggedArray[2] = new int[4]; // 第三行有 4 列
        
        // 为不规则二维数组赋值
        int value = 1;
        for (int i = 0; i < jaggedArray.length; i++) {
            for (int j = 0; j < jaggedArray[i].length; j++) {
                jaggedArray[i][j] = value;
                value++;
            }
        }
        
        // 遍历不规则二维数组
        for (int i = 0; i < jaggedArray.length; i++) {
            for (int j = 0; j < jaggedArray[i].length; j++) {
                System.out.print(jaggedArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

二维数组的应用场景

1. 矩阵运算：二维数组可以用于表示矩阵，进行矩阵的加法、乘法等运算
2. 表格数据：二维数组可以用于存储表格数据，如学生成绩表
3. 游戏棋盘：二维数组可以用于表示游戏棋盘，如井字棋、五子棋等
4. 图像处理：二维数组可以用于表示图像的像素数据

示例：二维数组的使用

示例 1：矩阵加法

public class MatrixAdditionExample {
    public static void main(String[] args) {
        int[][] matrix1 = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        int[][] matrix2 = {
            {9, 8, 7},
            {6, 5, 4},
            {3, 2, 1}
        };
        
        int[][] result = addMatrices(matrix1, matrix2);
        
        System.out.println("Matrix 1:");
        printMatrix(matrix1);
        
        System.out.println("Matrix 2:");
        printMatrix(matrix2);
        
        System.out.println("Result:");
        printMatrix(result);
    }
    
    public static int[][] addMatrices(int[][] matrix1, int[][] matrix2) {
        int rows = matrix1.length;
        int columns = matrix1[0].length;
        int[][] result = new int[rows][columns];
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                result[i][j] = matrix1[i][j] + matrix2[i][j];
            }
        }
        
        return result;
    }
    
    public static void printMatrix(int[][] matrix) {
        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();
        }
        System.out.println();
    }
}

示例 2：学生成绩表

public class StudentGradesExample {
    public static void main(String[] args) {
        String[] students = {"Alice", "Bob", "Charlie", "David"};
        String[] courses = {"Math", "English", "Science"};
        int[][] grades = {
            {90, 85, 95},
            {80, 75, 85},
            {95, 90, 80},
            {70, 80, 75}
        };
        
        // 打印成绩表
        System.out.println("Student Grades:");
        System.out.print("\t");
        for (String course : courses) {
            System.out.print(course + "\t");
        }
        System.out.println();
        
        for (int i = 0; i < students.length; i++) {
            System.out.print(students[i] + "\t");
            for (int j = 0; j < courses.length; j++) {
                System.out.print(grades[i][j] + "\t");
            }
            System.out.println();
        }
        
        // 计算每个学生的平均成绩
        System.out.println("\nAverage Grades:");
        for (int i = 0; i < students.length; i++) {
            int sum = 0;
            for (int j = 0; j < courses.length; j++) {
                sum += grades[i][j];
            }
            double average = (double) sum / courses.length;
            System.out.println(students[i] + ": " + average);
        }
    }
}

常见问题

1. 数组索引越界

症状：运行时错误：ArrayIndexOutOfBoundsException

解决方案：确保行索引和列索引在有效范围内

2. 空指针异常

症状：运行时错误：NullPointerException

解决方案：确保二维数组已经初始化，且每一行也已经初始化

3. 不规则二维数组的处理

症状：在处理不规则二维数组时，列索引越界

解决方案：在访问列元素时，使用 数组名[行索引].length 来获取当前行的列数

总结

二维数组是 Java 中一种重要的数据结构，它可以看作是一个表格，其中第一个维度表示行，第二个维度表示列。二维数组的初始化有静态初始化、动态初始化和默认初始化三种方式。

在使用二维数组时，需要注意：

• 二维数组的访问通过行索引和列索引来实现
• 二维数组的遍历需要使用嵌套循环
• 二维数组的每一行可以有不同的长度，这样的数组称为不规则二维数组
• 避免数组索引越界和空指针异常

通过合理使用二维数组，可以有效地处理矩阵运算、表格数据、游戏棋盘等二维数据结构。