嵌套的 for 循环如何在多维 arrays 上循环？

Question

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

这是代码：

int[][][][] array = new int[3][2][6][8];
int x = 0;

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        for (int k = 0; k < array[i][j].length; k++) {
            for (int n = 0; n < array[i][j][k].length; n++) {
                array[i][j][k][n] = ++x;
            }
        }
    }
}

这一行发生了什么：

array[i][j][k].length

更具体地说，我想知道为什么这个 line array[i][j][k].length循环正确的次数。

对我来说，它看起来像是在计算 new int[3][2][ [6] new int[3][2][6][8]; 让我的头脑完全理解它而不是仅仅能够编码它的简单英语翻译是什么？

我只是以array[i][j][k].length为例。 我可以对array[i][j].length提出同样的问题

Answer 1

与其将此处的array视为多维数组int[][][][] ，不如将其视为包含int[][][]的一维数组（长度为 3）。

你如何循环遍历一维数组？ 出色地，

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

现在将对array中的每个foo执行一些操作。 由于foo是另一个int[][]的一维数组（长度为 2），我们可以用同样的方式循环它：

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

bar是另一个包含int[]的一维数组（长度为 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...
        }
    }
}

最后我们循环遍历baz ，它也是一个整数的一维数组（长度为 8）：

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];
            for (int n = 0 ; n < baz.length ; n++) { // for each number in baz...
                // do something with baz[n]
            }
        }
    }
}

现在这里是“魔术”。 注意变量赋值：

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

如果您将baz替换为bar[k] ，然后将bar替换为foo[j] ，然后将foo替换为array[i] ，删除 go 时的变量声明，您将得到问题中的嵌套 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]

这就是array[i][j][k][n]的来源！

对我来说，它看起来像是在计算 new int[3][2][ [6] new int[3][2][6][8];

它实际上是在计算[8] 。 如果您仔细观察， array[i][j][k]对应于此处的baz ，其长度为 8。计算循环可能比语法中的索引更有用。 它是嵌套中的第四个循环，因此它在长度为 8 的第四维上循环。

Answer 2

多维数组可以被认为是 arrays 的数组（它们本身可以包含数组）。 arrays 数组与二维网格的区别在于“较小的” arrays 可以具有不同的长度。 使用array[i][j][k].length （例如），仅当第三维的每个数组的大小相同时才有效。 假设是这种情况，在不同级别查找 arrays 的长度将返回它们各自维度的大小。

Answer 3

基本上， int[][][][] array是 int 的 arrays 的 arrays 的数组。 所以在这里，对于int[3][2][6][8] ，您有一个 3 arrays 的数组，其中 2 个 arrays 的 6 个 arrays 的 8 intCZ。

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 ，因为来自同一维度的所有 arrays 都具有大小相同。

我们可以将一个 10 int 的整个数组添加到array[1][1] ，然后array[1][1].length将是7并且array[1][1][6].length将是ten 。

要理解和记住的最重要的事情是int[][][][] array是 arrays 的数组。 所以它循环了正确的次数，因为你没有离开数组和他的子数组（以及他的其他嵌套子数组......），因为你总是有它们的长度并且不会进一步 go。