Java二维数组的遍历

创建二维数组

public class TestArray05{
        public static void main(String[] args){
                //定义一个二维数组：
                int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
                
                int[] a1 = {1,2,3};
                arr[0] = a1;
                
                arr[1] = new int[]{4,5,6,7};
                
                arr[2] = new int[]{9,10};
        }
}

这是一个Java程序，用于演示如何定义和初始化一个二维整数数组。

首先，我们来逐步分析这段代码：

1. 在主方法中，首先定义了一个二维整数数组arr，其大小为3行。但是，每行的长度尚未指定（这正是该代码要做的）。
2. int[] a1 = {1,2,3};: 定义了一个名为a1的一维整数数组，并初始化为{1,2,3}。
3. arr[0] = a1;: 将一维数组a1赋值给二维数组arr的第一行。此时，arr的形状为：

1 2 3

4. arr[1] = new int[]{4,5,6,7};: 为二维数组arr的第二行赋值一个新的一维数组，包含4个整数：4, 5, 6, 和 7。此时，arr的形状为：

1 2 3
4 5 6 7

5. arr[2] = new int[]{9,10};: 为二维数组arr的第三行赋值一个新的长度为2的一维数组，包含整数9和10。此时，arr的形状为：

1 2 3
4 5 6 7
9 10

总结：这段代码演示了如何为一个二维整数数组分配行和每个行中的元素。但是请注意，这种方式的动态初始化虽然有时很方便，但在处理更复杂的数组操作时可能会带来一些困惑，因为它与常规的静态初始化方式有所不同。

二位数组初始化

在Java中，二维数组可以以静态、动态和默认的方式进行初始化。

1. 静态初始化：

静态初始化是在声明二维数组时直接分配内存并初始化数组元素。

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

在静态初始化时，每个子数组的大小必须相同，且每个子数组的大小在声明时必须已知。
2. 动态初始化：

动态初始化是在声明二维数组时只分配内存，然后在需要时再对数组元素进行赋值。

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

在动态初始化时，可以先声明二维数组，然后逐个对每个子数组进行初始化。子数组的大小可以在声明时未知，也可以在后续赋值时改变。
3. 默认初始化：

默认初始化是在声明二维数组后不进行任何初始化，这时数组的所有元素都将被自动初始化为默认值（对于整数类型，默认值为0）。

int[][] array2DDefault = new int[3][3]; // 所有元素默认初始化为0

默认初始化通常用于声明并创建一个空数组，然后在后续的代码中再对其进行赋值。

二位数组的遍历

public class TestArray05{
        public static void main(String[] args){
                //定义一个二维数组：
                int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
                
                int[] a1 = {1,2,3};
                arr[0] = a1;
                
                arr[1] = new int[]{4,5,6,7};
                
                arr[2] = new int[]{9,10};
                
                //读取6这个元素：
                //System.out.println(arr[1][2]);
                
                //对二维数组遍历：
                //方式1：外层普通for循环+内层普通for循环：
                for(int i=0;i<arr.length;i++){
                        for(int j=0;j<arr[i].length;j++){
                                System.out.print(arr[i][j]+"\t");
                        }
                        System.out.println();
                }
                
                //方式2：外层普通for循环+内层增强for循环：
                for(int i=0;i<arr.length;i++){
                        for(int num:arr[i]){
                                System.out.print(num+"\t");
                        }
                        System.out.println();
                }
                
                //方式3：外层增强for循环+内层增强for循环：
                for(int[] a:arr){
                        for(int num:a){
                                System.out.print(num+"\t");
                        }
                        System.out.println();
                }
                
                //方式4：外层增强for循环+内层普通for循环：
                for(int[] a:arr){
                        for(int i=0;i<a.length;i++){
                                System.out.print(a[i]+"\t");
                        }
                        System.out.println();
                }
        }
}

分析

以上代码中包含四种不同的循环嵌套方式，下面是对这四种循环嵌套的运行过程的分析：

方式1：外层普通for循环+内层普通for循环

运行过程：

1. 外层循环变量i从0开始，到arr.length-1结束。
2. 内层循环变量j从0开始，到arr[i].length-1结束。
3. 在内层循环中，使用arr[i][j]来访问二维数组的元素，并打印出来。
4. 内层循环结束后，执行System.out.println()打印换行。
5. 外层循环结束后，输出整个二维数组的元素。

方式2：外层普通for循环+内层增强for循环

运行过程：

1. 外层循环变量i从0开始，到arr.length-1结束。
2. 内层增强for循环遍历arr[i]数组中的所有元素。
3. 在内层循环中，使用num来访问一维数组的元素，并打印出来。
4. 内层循环结束后，执行System.out.println()打印换行。
5. 外层循环结束后，输出整个二维数组的元素。

方式3：外层增强for循环+内层增强for循环

运行过程：

1. 外层增强for循环遍历arr数组中的所有元素。
2. 内层增强for循环遍历当前元素（即子数组）中的所有元素。
3. 在内层循环中，使用num来访问元素，并打印出来。
4. 内层循环结束后，执行System.out.println()打印换行。
5. 外层循环结束后，输出整个二维数组的元素。

方式4：外层增强for循环+内层普通for循环

运行过程：

1. 外层增强for循环遍历arr数组中的所有元素。
2. 内层普通for循环遍历当前元素（即子数组）中的所有元素。
3. 在内层循环中，使用a[i]来访问元素，并打印出来。
4. 内层循环结束后，执行System.out.println()打印换行。
5. 外层循环结束后，输出整个二维数组的元素。