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 循环正确的次数。

对我来说，它看起来像是在计算 [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
}

现在将对 foo 中的每个 array 执行一些操作。由于 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] 的来源！

<块引用>

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

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

Answer 2

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

Answer 3

基本上，int[][][][] array是int数组的数组数组。所以在这里，对于 int[3][2][6][8]，你有一个由 3 个数组组成的数组，由 2 个数组组成，其中 6 个数组包含 8 个整数。

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

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

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

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

3 个答案: