Java 中的嵌套循环

当一个循环体内部包含另一个循环时，我们称之为嵌套循环。下面是一个嵌套 for 循环的示例。

// outer loop
for (int i = 1; i <= 5; ++i) {
  // codes

  // inner loop
  for(int j = 1; j <=2; ++j) {
    // codes
  }
..
}

在这里，我们在另一个 for 循环内部使用了 for 循环。

我们可以使用嵌套循环来遍历三周内的每一天。

在这种情况下，我们可以创建一个循环迭代三次（3 周）。然后在循环内部，我们可以创建另一个循环迭代 7 次（7 天）。

示例 1：Java 嵌套 for 循环

class Main {
  public static void main(String[] args) {

    int weeks = 3;
    int days = 7;

    // outer loop prints weeks
    for (int i = 1; i <= weeks; ++i) {
      System.out.println("Week: " + i);

      // inner loop prints days
      for (int j = 1; j <= days; ++j) {
        System.out.println("  Day: " + j);
      }
    }
  }
}

输出

Week: 1
  Day: 1
  Day: 2
  Day: 3
    .....  ..  ....
Week: 2
  Day: 1
  Day: 2
  Day: 3
  ....  ..  ....
....  .. ....

在上面的示例中，外层循环迭代 3 次并打印 3 周。内层循环迭代 7 次并打印 7 天。

我们也可以用 while 和 do...while 以类似的方式创建嵌套循环。

注意：可以将一种类型的循环放在另一种循环的循环体内。例如，我们可以将一个 for 循环放在 while 循环内。

示例 2：在 while 循环中嵌套 for 循环

class Main {
  public static void main(String[] args) {

    int weeks = 3;
    int days = 7;
    int i = 1;

    // outer loop
    while (i <= weeks) {
      System.out.println("Week: " + i);

      // inner loop
      for (int j = 1; j <= days; ++j) {
        System.out.println("  Days: " + j);
      }
      ++i;
    }
  }
}

输出:

Week: 1
  Day: 1
  Day: 2
  Day: 3
  .... .. ....
Week: 2
  Day: 1
  Day: 2
  Day: 3
  .... .. ....
.... .. ....

这里可以看到，**示例 1** 和 **示例 2** 的输出是相同的。

示例 3：使用 Java 嵌套循环创建图案

我们可以在 Java 中使用嵌套循环来创建全金字塔、半金字塔、倒金字塔等图案。

这是一个使用嵌套循环创建半金字塔图案的程序。

class Main {
  public static void main(String[] args) {

    int rows = 5;

    // outer loop
    for (int i = 1; i <= rows; ++i) {

      // inner loop to print the numbers
      for (int j = 1; j <= i; ++j) {
        System.out.print(j + " ");
      }
      System.out.println("");
    }
  }
}

输出

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

要了解更多，请访问 打印金字塔和图案的 Java 程序。

嵌套循环中的 break 和 continue

当我们在内层循环中使用 break 语句时，它会终止内层循环，但不会终止外层循环。例如，

class Main {
  public static void main(String[] args) {
    
    int weeks = 3;
    int days = 7;

    // outer loop
    for(int i = 1; i <= weeks; ++i) {
      System.out.println("Week: " + i);

      // inner loop
      for(int j = 1; j <= days; ++j) {
        
        // break inside the inner loop
        if(i == 2) {
          break;
        }
        System.out.println("  Days: " + j);
      }
    }
  }
}

输出

Week: 1
  Day: 1
  Day: 2
  .... .. ....
Week: 2
Week: 3
  Day: 1
  Day: 2
  .... .. ....
.... .. ....

在上面的示例中，我们在内层 for 循环中使用了 break 语句。这里，当 i 为 2 时，程序会跳过该循环。

因此，第 2 周 的天数没有被打印。然而，打印周的外层循环不受影响。

同样，当我们在内层循环中使用 continue 语句时，它只会跳过内层循环的当前迭代。外层循环不受影响。例如，

class Main {
  public static void main(String[] args) {
    
    int weeks = 3;
    int days = 7;

    // outer loop
    for(int i = 1; i <= weeks; ++i) {
      System.out.println("Week: " + i);

      // inner loop
      for(int j = 1; j <= days; ++j) {
        
        // continue inside the inner loop
        if(j % 2 != 0) {
          continue;
        }
        System.out.println("  Days: " + j);
      }
    }
  }
}

输出

Week: 1
  Days: 2
  Days: 4
  Days: 6
Week: 2
  Days: 2
  Days: 4
  Days: 6
Week: 3
  Days: 2
  Days: 4
  Days: 6

在上面的示例中，我们在内层 for 循环中使用了 continue 语句。请注意代码，

if(j % 2 != 0) {
  continue;
}

这里，当 j 的值为奇数时，将执行 continue 语句。因此，程序只打印偶数天。

我们可以看到 continue 语句只影响了内层循环。外层循环工作正常。