Java 不了解二维数组的每个循环

从我的书中得到了这个例子：

public class ForEach3 {
public static void main(String args[]){
    int sum=0;
    int numbers [][]=new int[3][5];

    for(int i=0;i<3;i++)
    {
        for(int j=0;j<5;j++)
        {
            numbers[i][j]=(i+1)*(j+1);
        }
    }


    for(int x[]:numbers)
    {
        for(int y:x)
        {
            System.out.println("Number is: "+y);
            sum+=y;
        }
    }
}
}

为什么我们要做这个循环对于（整数y:x）

---

这是让我很困惑的部分，我知道如何使用基本数组为每个循环执行基本操作，但当我使用二维数组时，这让我很困惑。

首先，我们将把

数字

重命名为

网格

，

x

重命名为

行

，将

y

重命名为

单元格

。让我们把它分解一下

for（int x[]：number）

可以重写为

for（int[]行：网格）

。这将迭代存储在

网格中的所有
int[]
s。对于每个
int[]
，
行
设置为
int[]

内部循环
for（int y:x）
，重写为
for（int cell:row）
对
行的所有值进行迭代，这是一个
int[]
，并将
单元格设置为等于每个值。第一次运行外部循环和内部循环时，
行
等于
网格[0]
，
单元格
等于
行[0]
，或
网格[0][0]
。这将一直持续到
网格中的每个值都被使用。
首先，我们将
数字
重命名为
网格
，
x
为
行
，
y
为
单元格
。让我们把它分解一下

for(int x[]:numbers)

for（int x[]：number）
可以重写为
for（int[]行：网格）
。这将迭代存储在
网格中的所有
int[]
s。对于每个
int[]
，
行
设置为
int[]

内部循环
for（int y:x）
，重写为
for（int cell:row）
对
行的所有值进行迭代，这是一个
int[]
，并将
单元格设置为等于每个值。第一次运行外部循环和内部循环时，
行
等于
网格[0]
，
单元格
等于
行[0]
，或
网格[0][0]
。这将一直持续到
网格中的每个值都已被使用为止

for(int x[]:numbers)

这里您迭代数字[0]、数字[1]、数字[2]，数字[i]的值被放入变量x中。那么x是一个一维数组，您可以在其中迭代：

for(int y:x)

这里您迭代数字[0]、数字[1]、数字[2]，数字[i]的值被放入变量x中。那么x是一个一维数组，您可以在其中迭代：

for(int y:x)

第一个循环描述了第一个数组（
length==3
）的索引，其中还有
length==5
的数组。第二个循环是遍历数字数组，并在新行中打印出每个值

因此它从
[0][0…4]
到
[1][0…4]
，最后一个
[2][0…4]
，并打印出每个值。
第一个循环描述了第一个数组（
长度==3
）的索引，其中还有
长度==5的数组。第二个循环是遍历数字数组，并在新行中打印出每个值

所以它从
[0][0…4]
到
[1][0…4]
，最后是
[2][0…4]
，并打印出每个值。
关键点在于：实际上没有“二维数组”这样的东西。正如
int[]
是
int
的数组一样，
int[][]
也是
int[]
的数组。当你说
myArray[1][2]
时，它实际上并没有进入网格的坐标（1，2）
myArray
是一个数组数组，因此
myArray[1]
提供一个数组，该数组由
[2]
索引

或者，重写示例的第一部分：

int numbers[][] = new int[3][5];
for(int i = 0; i < 3; i++)
{
    int[] array = numbers[i];
    for(int j=0;j<5;j++)
    {
        array[j]=(i+1)*(j+1);
    }
}

int number[][]=新int[3][5]；
对于（int i=0；i<3；i++）
{
int[]数组=数字[i]；
对于（int j=0；j这里是关键点：实际上没有“二维数组”这样的东西。正如
int[]
是
int
的数组一样，
int[]
是
int[]
的数组。当你说
myArray[1][2]
时，它并没有真正进入坐标（1，2）网格的。
myArray
是数组的数组，因此
myArray[1]
提供一个数组，该数组由
[2]
索引

或者，重写示例的第一部分：

int numbers[][] = new int[3][5];
for(int i = 0; i < 3; i++)
{
    int[] array = numbers[i];
    for(int j=0;j<5;j++)
    {
        array[j]=(i+1)*(j+1);
    }
}

int number[][]=新int[3][5]；
对于（int i=0；i<3；i++）
{
int[]数组=数字[i]；
对于（int j＝0；j＜p＞ok），请考虑此代码：

for(int x[] : numbers) {
    for(int y : x) {
        System.out.println("Number is: " + y);
    }
}

现在，在第一行，你会看到一些奇怪的语法。
intx[]
和
intx[/code>说的是相同的事情（只是说相同的事情的不同方式）基本上，您是在声明一个数组。现在，
foreach
循环获取您在
：
或
数字之后指定的数组中的每个元素，并将其放入您在
：
或
x
之前声明的变量中

现在，理解这段代码的最好方法是理解2D数组是如何工作的。它们不是什么新的特殊东西，2D数组只是一个数组数组。与传统数组中的每个元素都是一个值不同，每个元素都是一个完整的另一个数组，都有自己的值集。因此，让我们再次看代码的顶行

for(int x[] : numbers) {

这在英语中翻译为：“对于
数字中的每个元素，将其值放入
x
，然后运行下面的代码。”请记住，因为
numbers
是一个数组，所以它的每个元素都是一个数组。因此，代码运行第一次迭代，并检索
numbers
（索引0处）中的第一个元素，该元素是
int
s的数组。然后，它运行以下代码：

for(int y : x) {
    System.out.println("Number is: " + y);
}

代码的顶行可以翻译成英语，如下所示：“对于
x
中的每个元素，将其值放入
y
，然后运行下面的代码。”因此，它就是这样做的。代码运行第一次迭代并检索