Java 嵌套for循环如何在多维数组上循环？

这是一个有点奇怪的问题，很难找到答案

代码如下：

int[]数组=新的int[3][2][6][8]；
int x=0；
for（int i=0；i

这一行发生了什么：

数组[i][j][k].长度

更具体地说，我想知道为什么此行

array[I][j][k].length

循环次数正确

在我看来，它似乎在计算

新int[3][2][6][8]中的
[6]

什么是简单的英语翻译让我的大脑完全理解它，而不是仅仅能够编码它

我只是以
array[I][j][k].length
为例。对于
数组[I][j]，我可以问同样的问题。长度
多维数组可以看作是数组的数组（数组本身可以包含数组）。阵列阵列与二维网格的区别在于，“较小”阵列可以具有不同的长度。使用
数组[i][j][k].length
（例如），仅当第三维的每个数组大小相同时才有效。假设是这种情况，在不同级别查找数组的长度将返回其各自维度的大小。
多维数组可以被视为数组数组（其本身可以包含数组）。阵列阵列与二维网格的区别在于，“较小”阵列可以具有不同的长度。使用
数组[i][j][k].length
（例如），仅当第三维的每个数组大小相同时才有效。假设是这种情况，在不同级别查找数组的长度将返回其各自维度的大小。
与其将
数组
视为多维数组
int[][[]]
，不如将其视为包含
int[][]
的一维数组（长度为3）

如何在一维数组中循环？那么

for (int i = 0; i < array.length; i++) { // for each foo in array...
    int[][][] foo = array[i];
    // do something with foo
}

bar
是另一个包含
int[]
s的一维数组（长度为6）。我们也来循环一下：

for (int i = 0; i < array.length; i++) { // for each foo in array...
    int[][][] foo = array[i];
    for (int j = 0 ; j < foo.length ; j++) { // for each bar in foo...
        int[][] bar = foo[j];
        for (int k = 0 ; k < bar.length ; k++) { // for each baz in bar...
            int[] baz = bar[k];
            // do something with baz...
        }
    }
}

现在是“魔法”。请注意变量赋值：

foo = array[i];
bar = foo[j];
baz = bar[k];

如果将
baz
替换为
bar[k]
，然后将
bar
替换为
foo[j]
，然后将
foo
替换为
array[i]
，在执行过程中删除变量声明，则问题中会出现嵌套的for循环

例如，下面是对
baz[n]
的逐步可视化：

baz[n]
bar[k][n] // replace baz with bar[k]
foo[j][k][n] // replace bar with foo[j]
array[i][j][k][n] // replace foo with array[i]

这就是
数组[i][j][k][n]
的来源

在我看来，它似乎在计算
新int[3][2][6][8]中的
[6]

它实际上是在计算
[8]
。如果仔细观察，
array[i][j][k]
对应于这里的
baz
，长度为8。计数循环可能比计算语法中的索引更有用。它是嵌套中的第四个循环，因此它在第四维上循环，长度为8。
与其把
数组看作是一个多维数组
int[][][[]
，不如把它看作是一个包含
int[][][][]
的一维数组（长度为3）

如何在一维数组中循环？那么

for (int i = 0; i < array.length; i++) { // for each foo in array...
    int[][][] foo = array[i];
    // do something with foo
}

bar
是另一个包含
int[]
s的一维数组（长度为6）。我们也来循环一下：

for (int i = 0; i < array.length; i++) { // for each foo in array...
    int[][][] foo = array[i];
    for (int j = 0 ; j < foo.length ; j++) { // for each bar in foo...
        int[][] bar = foo[j];
        for (int k = 0 ; k < bar.length ; k++) { // for each baz in bar...
            int[] baz = bar[k];
            // do something with baz...
        }
    }
}

现在是“魔法”。请注意变量赋值：

foo = array[i];
bar = foo[j];
baz = bar[k];

如果将
baz
替换为
bar[k]
，然后将
bar
替换为
foo[j]
，然后将
foo
替换为
array[i]
，在执行过程中删除变量声明，则问题中会出现嵌套的for循环

例如，下面是对
baz[n]
的逐步可视化：

baz[n]
bar[k][n] // replace baz with bar[k]
foo[j][k][n] // replace bar with foo[j]
array[i][j][k][n] // replace foo with array[i]

这就是
数组[i][j][k][n]
的来源

在我看来，它似乎在计算
新int[3][2][6][8]中的
[6]

它实际上是在计算
[8]
。如果仔细观察，
array[i][j][k]
对应于这里的
baz
，长度为8。计数循环可能比计算语法中的索引更有用。这是嵌套中的第四个循环，所以它在第四维上循环，长度为8。
基本上，
int[][][[]]数组是int数组数组的数组。
int[3][2][6][8]
这里有一个3数组2数组6数组8 int

array[i]
从名为
array
的变量中获取第i个数组
array[i][k]
给出第i个数组的第k个数组

因此
array[i][j][k].length
从名为
array
的变量中为您提供第i个数组的第j个数组的第k个数组的长度。在这里，由于您从
int[3][2][6][8]
创建了所有数组，因此无论i、j和k，您将始终具有长度
8
，因为来自同一维度的所有数组都具有相同的大小

我们可以在
数组[1][1]
中添加一个完整的10 int数组，然后
数组[1][1]。长度
将是
7
和
数组[1][6]。长度
将是
10

要理解和记住的最重要的事情是
int[][]]array
是数组的数组。因此，它循环的次数是正确的，因为你不会离开数组和他的子数组（以及其他嵌套的子数组…），因为你总是有它们的长度，而且不会走得更远。
基本上，
int[][][[]数组
是一个数组的数组