嵌套的 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。