嵌套的for循环如何遍历多维数组？

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

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

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

我只是以 array[i][j][k].length 为例。我可以为 array[i][j].length

问同样的问题

Answer 1

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

Answer 2

与其将此处的 array 视为多维数组 int[][][][]，不如将其视为包含 int[][][]s 的一维数组（长度为 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]，删除随着您的变量声明，您会在问题中得到嵌套的 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]的由来！

To me it looks like it is counting the [6] in new int[3][2][6][8];

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

Answer 3

基本上，int[][][][] array是一个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，因为来自同一维度的所有数组都具有相同的大小。

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

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

嵌套的for循环如何遍历多维数组？

How do nested for loops loop over muldimensional arrays?

java

arrays

for-loop

nested-loops

multidimensional-array