Java 是否可以在没有两个循环的情况下对二维数组进行迭代？

例如，如果我有：

int Myarray[][] = new int[][] {{1,2}, {3,4}};
for (int line=0; line < Myarray.length; line++) {
    for (int column = 0; column < Myarray[0].length; column++) {
        // do something ...
    }
}

intmyarray[][]=newint[][]{{1,2}，{3,4}；
对于（int line=0；line

---

如果没有两个循环，我如何遍历整个阵列？

您可以只使用一个循环：

for (int i = 0; i < Myarray.length*Myarray.length; i++) {
    int row = i / Myarray.length;
    int col = i % Myarray.length;
    System.out.println(Myarray[row][col]);
}

for（int i=0；i

但这假设二维阵列是正方形的，即其宽度和长度在任何地方都相同。另一种说法是2D阵列不是锯齿状的

---

注意：正如上面提到的@Thilo，这不会使事情运行得更快。如果需要接触数组中的每个元素，那么我建议的代码和当前的双循环基本上具有相同的复杂性。

您可以只使用一个循环：

for (int i = 0; i < Myarray.length*Myarray.length; i++) {
    int row = i / Myarray.length;
    int col = i % Myarray.length;
    System.out.println(Myarray[row][col]);
}

for（int i=0；i

但这假设二维阵列是正方形的，即其宽度和长度在任何地方都相同。另一种说法是2D阵列不是锯齿状的

---

注意：正如上面提到的@Thilo，这不会使事情运行得更快。如果需要接触数组中的每个元素，那么我建议的代码和当前的双循环基本上具有相同的复杂性。

您可以不使用任何循环进行迭代：

void recursive(int[][] array, int r, int c) {
  if (r >= array.length) return;
  if (c >= array[r].length) {
    recursive(array, r+1, 0);
  } else {
    System.out.println(array[r][c]);
    recursive(array, r, c+1);
  }
}

然后使用递归（数组，0，0）调用以开始

---

但这样做没有实际好处。这将执行得很差，因为调用方法与增加int相比需要付出额外的努力。（另外，根据数组的大小，可能会导致堆栈溢出）。

您可以在没有任何循环的情况下进行迭代：

void recursive(int[][] array, int r, int c) {
  if (r >= array.length) return;
  if (c >= array[r].length) {
    recursive(array, r+1, 0);
  } else {
    System.out.println(array[r][c]);
    recursive(array, r, c+1);
  }
}

然后使用递归（数组，0，0）调用以开始

---

但这样做没有实际好处。这将执行得很糟糕，因为调用一个方法与仅仅增加一个int相比需要付出额外的努力。（另外，根据数组的大小，可能会导致堆栈溢出）。

如果您不需要知道“do something”代码（未在问题中说明）中的行或列，您可以：

Arrays.stream(Myarray).flatMap(Arrays:stream)
    .forEach(n -> /* do something with “n”, the cell value */);

---

如果您不需要知道“做点什么”代码中的行或列（未在问题中说明），您可以：

Arrays.stream(Myarray).flatMap(Arrays:stream)
    .forEach(n -> /* do something with “n”, the cell value */);

---

没有。但是两个循环有什么问题？总迭代计数将是相同的。如果可以保证所有组件数组的长度相同且不为空，则可以对（i in[0…cols*rows]）{（x，y）=transformIndex}执行

。但是，再一次：为什么？你可以考虑使用一维数组。问题是，我在研究是否有办法减少这个问题的渐近复杂性“O（n ^ 2）”。只要迭代的总数是相同的，这对你的渐近复杂性没有任何影响。你需要知道什么样的行和列值在“do something”代码，还是只需要每个单元格上的值？不需要。但两个循环有什么问题？总迭代计数将是相同的。如果可以保证所有组件数组的长度相同且不为空，则可以对（i in[0…cols*rows]）{（x，y）=transformIndex}执行
但是，为什么？你可以考虑使用一维数组。问题是，我在研究是否有一种降低渐近复杂性的方法“O（n ^ 2）”。只要总迭代次数相同，这对你的渐进复杂性没有任何影响。你需要知道“做点什么”中的行和列值是什么吗代码，还是只需要每个单元格的值？你是对的。但是，为了在文章中进行演示，更有趣的是说解是O（n）。什么？你怎么能说解是O（n）如果循环需要n*n=n^2次迭代？你是对的。但是，为了在文章中进行演示，更有趣的是说解决方案是O（n）。什么？如果循环需要n*n=n^2次迭代，你怎么能说解决方案是O（n）？