什么是嵌套 for 循环？

嵌套 for 循环指的是在一个 for 循环的内部，包含了另一个完整的 for 循环，外层的 for 循环每执行一次，内层的 for 循环就会完整地执行一遍。

这就像一个时钟：

• 外层循环 就像 时针，它走得慢,每小时移动一格。
• 内层循环 就像 分针，它走得快,每分钟移动一格。

当时针从 1 点走到 2 点时，分针已经完整地转了一圈（60 分钟），同理，外层循环执行一次,内层循环会执行它完整的所有次数。

基本语法

for (初始化表达式1; 循环条件1; 更新表达式1) {
    // 外层循环的代码块
    for (初始化表达式2; 循环条件2; 更新表达式2) {
        // 内层循环的代码块
        // 这里可以访问外层循环的变量
    }
    // 外层循环继续执行的代码
}

执行流程

1. 初始化：执行 初始化表达式1（int i = 0;）。
2. 条件判断：检查 循环条件1（i < 5;），如果为 true，则进入循环体；如果为 false，则跳过整个嵌套循环,执行后续代码。
3. 执行外层循环体：
   • 执行外层循环中 内层 for 循环之前的代码（如果有）。
   • 进入内层循环：
     • 执行 初始化表达式2（int j = 0;）。
     • 检查 循环条件2（j < 3;），如果为 true,则执行内层循环体。
     • 执行内层循环体代码。
     • 执行 更新表达式2（j++）。
     • 重复步骤 b-d，直到 循环条件2 为 false。
   • 执行外层循环中 内层 for 循环之后的代码（如果有）。
4. 更新外层循环：执行 更新表达式1（i++）。
5. 重复：回到步骤 2，继续判断 循环条件1，直到它为 false,整个嵌套循环结束。

代码示例与图解

示例1：打印乘法口诀表（九九表）

这是一个非常经典的嵌套循环应用。

public class NestedLoopExample {
    public static void main(String[] args) {
        // 外层循环控制行数 (i 从 1 到 9)
        for (int i = 1; i <= 9; i++) {
            // 内层循环控制每行的列数 (j 从 1 到 i)
            for (int j = 1; j <= i; j++) {
                // 使用 \t 来对齐，使输出更美观
                System.out.print(j + " * " + i + " = " + (i * j) + "\t");
            }
            // 内层循环结束后，换行，开始打印下一行
            System.out.println();
        }
    }
}

执行流程图解：

外层循环 i = 1:
  -> 内层循环 j 从 1 到 1:
      -> 打印 "1 * 1 = 1"
  -> 换行
外层循环 i = 2:
  -> 内层循环 j 从 1 到 2:
      -> 打印 "1 * 2 = 2"
      -> 打印 "2 * 2 = 4"
  -> 换行
外层循环 i = 3:
  -> 内层循环 j 从 1 到 3:
      -> 打印 "1 * 3 = 3"
      -> 打印 "2 * 3 = 6"
      -> 打印 "3 * 3 = 9"
  -> 换行
... 以此类推，直到 i = 9

输出结果：

1 * 1 = 1   
1 * 2 = 2   2 * 2 = 4   
1 * 3 = 3   2 * 3 = 6   3 * 3 = 9   
1 * 4 = 4   2 * 4 = 8   3 * 4 = 12  4 * 4 = 16  
1 * 5 = 5   2 * 5 = 10  3 * 5 = 15  4 * 5 = 20  5 * 5 = 25  
1 * 6 = 6   2 * 6 = 12  3 * 6 = 18  4 * 6 = 24  5 * 6 = 30  6 * 6 = 36  
1 * 7 = 7   2 * 7 = 14  3 * 7 = 21  4 * 7 = 28  5 * 7 = 35  6 * 7 = 42  7 * 7 = 49  
1 * 8 = 8   2 * 8 = 16  3 * 8 = 24  4 * 8 = 32  5 * 8 = 40  6 * 8 = 48  7 * 8 = 56  8 * 8 = 64  
1 * 9 = 9   2 * 9 = 18  3 * 9 = 27  4 * 9 = 36  5 * 9 = 45  6 * 9 = 54  7 * 9 = 63  8 * 9 = 72  9 * 9 = 81  

示例2：打印一个由星号(*)组成的矩形

public class PrintRectangle {
    public static void main(String[] args) {
        int rows = 4;
        int cols = 6;
        // 外层循环控制行数
        for (int i = 0; i < rows; i++) {
            // 内层循环控制每行的列数（打印星号）
            for (int j = 0; j < cols; j++) {
                System.out.print("* ");
            }
            // 每行打印完毕后换行
            System.out.println();
        }
    }
}

输出结果：

重要注意事项

a. 变量作用域

内层循环可以访问外层循环声明的变量，但反之不行，我们会为内外层循环使用不同的变量名（如 i, j, k）,以避免混淆和错误。

for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 3; j++) {
        // 这里的 i 和 j 都可以被访问
        System.out.println("i: " + i + ", j: " + j);
    }
    // 这里的 i 可以被访问，但 j 不可以
    // System.out.println(j); // 编译错误！
}

b. 性能考虑

嵌套循环的时间复杂度通常是 O(n*m)，n 和 m 是内外层循环的次数，如果循环次数很大，嵌套循环的执行时间会急剧增加，在处理大规模数据时，需要谨慎使用嵌套循环,并思考是否存在更优化的算法。

c. break 和 continue 的作用

• break：在嵌套循环中，break 语句只会跳出它所在的那一层循环。

  for (int i = 0; i < 3; i++) {
      System.out.println("外层循环 i = " + i);
      for (int j = 0; j < 3; j++) {
          if (j == 1) {
              break; // 只会跳出内层循环
          }
          System.out.println("  内层循环 j = " + j);
      }
  }

  输出：

  外层循环 i = 0
    内层循环 j = 0
  外层循环 i = 1
    内层循环 j = 0
  外层循环 i = 2
    内层循环 j = 0

• continue：在嵌套循环中，continue 语句只会跳过它所在的那一层循环的当次剩余代码,直接进入该层循环的下次迭代。

  for (int i = 0; i < 2; i++) {
      System.out.println("外层循环 i = " + i);
      for (int j = 0; j < 3; j++) {
          if (j == 1) {
              continue; // 跳过内层循环中 j=1 时的 System.out.println
          }
          System.out.println("  内层循环 j = " + j);
      }
  }

  输出：

  外层循环 i = 0
    内层循环 j = 0
    内层循环 j = 2
  外层循环 i = 1
    内层循环 j = 0
    内层循环 j = 2

如果要从嵌套循环的最内层直接跳出所有外层循环，可以使用带标签的 break。

outerLoop: // 定义一个标签
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i == 2 && j == 2) {
            break outerLoop; // 跳出 outerLoop 标记的整个循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}

掌握嵌套 for 循环是编程中的一个重要技能，它让你能够处理更复杂的、具有层次结构的问题。