为什么需要 ArrayList 的二维数组？

标准的 Java 二维数组（int[][]）有几个固有的缺点：

1. 长度固定：一旦创建，其行数和列数就不能改变。
2. 初始化复杂：创建一个不规则的二维数组（比如每行的列数不同）比较麻烦。

ArrayList 的核心优势是动态大小，可以随时添加或删除元素，使用 ArrayList 的组合（ArrayList<ArrayList<T>>）可以创建一个真正动态的、每行长度可以不同的二维结构。

核心概念：ArrayList<ArrayList<T>>

在 Java 中，一个“二维的 ArrayList”实际上是一个 ArrayList，它的每一个元素又是一个 ArrayList。

• 外层 ArrayList：代表“行”。
• 内层 ArrayList：代表每一行中的“列”。

你可以把它想象成一个由多行组成的表格,每一行本身也是一个可以动态伸缩的列表。

如何创建和初始化

1 基本创建

最基本的方式是创建一个空的 ArrayList，然后逐行添加。

import java.util.ArrayList;
public class ArrayList2DExample {
    public static void main(String[] args) {
        // 1. 创建一个空的二维 ArrayList
        ArrayList<ArrayList<String>> matrix = new ArrayList<>();
        // 2. 创建第一行 (第一个 ArrayList)
        ArrayList<String> row1 = new ArrayList<>();
        row1.add("A");
        row1.add("B");
        row1.add("C");
        // 3. 将第一行添加到矩阵中
        matrix.add(row1);
        // 4. 创建第二行，并直接在添加时初始化
        ArrayList<String> row2 = new ArrayList<>();
        row2.add("D");
        row2.add("E");
        matrix.add(row2);
        // 5. 创建第三行，只添加一个元素
        ArrayList<String> row3 = new ArrayList<>();
        row3.add("F");
        matrix.add(row3);
        // matrix 结构如下:
        // [ ["A", "B", "C"],
        //   ["D", "E"],
        //   ["F"] ]
    }
}

2 使用循环初始化（推荐）

对于规则的二维结构,使用循环初始化更高效。

import java.util.ArrayList;
public class ArrayList2DExample {
    public static void main(String[] args) {
        int rows = 3;
        int cols = 4;
        ArrayList<ArrayList<Integer>> matrix = new ArrayList<>();
        for (int i = 0; i < rows; i++) {
            // 为每一行创建一个新的 ArrayList
            ArrayList<Integer> row = new ArrayList<>();
            for (int j = 0; j < cols; j++) {
                // 向行中添加元素
                row.add(i * cols + j); // 示例：填充 0, 1, 2...
            }
            // 将行添加到矩阵中
            matrix.add(row);
        }
        // matrix 结构如下:
        // [ [0, 1, 2, 3],
        //   [4, 5, 6, 7],
        //   [8, 9, 10, 11] ]
    }
}

如何访问元素

访问元素和标准二维数组语法类似,使用 get() 方法。

• matrix.get(i) 获取第 i 行（一个 ArrayList）。
• matrix.get(i).get(j) 获取第 i 行第 j 列的元素。

public class AccessExample {
    public static void main(String[] args) {
        ArrayList<ArrayList<String>> matrix = new ArrayList<>();
        matrix.add(new ArrayList<>(List.of("A", "B")));
        matrix.add(new ArrayList<>(List.of("C", "D", "E")));
        // 获取第 1 行 (索引为 0)
        ArrayList<String> firstRow = matrix.get(0); // firstRow 是 ["A", "B"]
        System.out.println("第一行: " + firstRow);
        // 获取第 1 行第 2 列的元素 (索引为 0, 1)
        String element = matrix.get(0).get(1);
        System.out.println("元素 (0, 1): " + element); // 输出 B
        // 获取元素 (1, 2)
        String element2 = matrix.get(1).get(2);
        System.out.println("元素 (1, 2): " + element2); // 输出 E
    }
}

注意：和数组一样，索引从 0 开始，如果索引越界，会抛出 IndexOutOfBoundsException。

如何修改元素

同样使用 set() 方法。

public class ModifyExample {
    public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> matrix = new ArrayList<>();
        matrix.add(new ArrayList<>(List.of(1, 2, 3)));
        matrix.add(new ArrayList<>(List.of(4, 5, 6)));
        System.out.println("修改前: " + matrix);
        // 输出: 修改前: [[1, 2, 3], [4, 5, 6]]
        // 将第 1 行第 3 列的元素 (索引 0, 2) 从 3 改为 30
        matrix.get(0).set(2, 30);
        System.out.println("修改后: " + matrix);
        // 输出: 修改后: [[1, 2, 30], [4, 5, 6]]
    }
}

如何添加/删除元素

这是 ArrayList 二维数组相比普通二维数组的最大优势。

1 添加元素

• 添加新行：使用外层 ArrayList 的 add() 方法。
• 在特定行添加新列：先获取该行，再使用内层 ArrayList 的 add() 方法。

public class AddElementExample {
    public static void main(String[] args) {
        ArrayList<ArrayList<String>> matrix = new ArrayList<>();
        matrix.add(new ArrayList<>(List.of("A", "B")));
        // 1. 添加一个新行
        ArrayList<String> newRow = new ArrayList<>();
        newRow.add("X");
        matrix.add(newRow);
        // 2. 在第 1 行 (索引 0) 的末尾添加一个新元素 "C"
        matrix.get(0).add("C");
        // 3. 在第 2 行 (索引 1) 的开头添加一个新元素 "Y"
        matrix.get(1).add(0, "Y");
        System.out.println(matrix);
        // 输出: [[A, B, C], [Y, X]]
    }
}

2 删除元素

• 删除一整行：使用外层 ArrayList 的 remove() 方法。
• 删除特定行的某一列：先获取该行，再使用内层 ArrayList 的 remove() 方法。

public class RemoveElementExample {
    public static void main(String[] args) {
        ArrayList<ArrayList<String>> matrix = new ArrayList<>();
        matrix.add(new ArrayList<>(List.of("A", "B", "C")));
        matrix.add(new ArrayList<>(List.of("D", "E", "F")));
        System.out.println("删除前: " + matrix);
        // 输出: 删除前: [[A, B, C], [D, E, F]]
        // 1. 删除第 2 行 (索引 1)
        matrix.remove(1);
        // 2. 删除第 1 行 (索引 0) 的第 2 列 (索引 1) 的元素 "B"
        matrix.get(0).remove(1);
        System.out.println("删除后: " + matrix);
        // 输出: 删除后: [[A, C]]
    }
}

如何遍历

可以使用传统的 for 循环，也可以使用更简洁的 for-each 循环或 Java 8 的 Stream API。

1 使用 for-each 循环（推荐）

public class TraversalExample {
    public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> matrix = new ArrayList<>();
        matrix.add(new ArrayList<>(List.of(1, 2, 3)));
        matrix.add(new ArrayList<>(List.of(4, 5, 6)));
        System.out.println("使用 for-each 遍历:");
        for (ArrayList<Integer> row : matrix) {
            for (Integer value : row) {
                System.out.print(value + " ");
            }
            System.out.println(); // 换行
        }
        /*
        输出:
        使用 for-each 遍历:
        1 2 3
        4 5 6
        */
    }