7.5 嵌套循环

嵌套循环的概念

嵌套循环是指在一个循环的循环体中包含另一个循环。在 Java 中，任何类型的循环（for、while、do…while）都可以相互嵌套。

嵌套循环的语法

for 循环嵌套

for (初始化表达式1; 条件表达式1; 更新表达式1) {
    // 外层循环体
    for (初始化表达式2; 条件表达式2; 更新表达式2) {
        // 内层循环体
    }
}

while 循环嵌套

while (条件表达式1) {
    // 外层循环体
    while (条件表达式2) {
        // 内层循环体
    }
}

do…while 循环嵌套

do {
    // 外层循环体
    do {
        // 内层循环体
    } while (条件表达式2);
} while (条件表达式1);

混合嵌套

for (初始化表达式; 条件表达式; 更新表达式) {
    // 外层循环体
    while (条件表达式2) {
        // 内层循环体
    }
}

嵌套循环的执行流程

1. 外层循环开始执行
2. 当外层循环条件满足时，执行外层循环体
3. 内层循环开始执行，直到内层循环条件不满足
4. 内层循环结束后，继续执行外层循环的更新表达式
5. 重复步骤 2-4，直到外层循环条件不满足

嵌套循环的使用

示例 1：打印乘法表

public class MultiplicationTableExample {
    public static void main(String[] args) {
        System.out.println("Multiplication Table:");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " × " + i + " = " + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}

输出结果：

Multiplication Table:
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 TriangleExample {
    public static void main(String[] args) {
        int rows = 5;
        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

输出结果：

* 
* * 
* * * 
* * * * 
* * * * *

示例 3：打印倒三角形

public class ReverseTriangleExample {
    public static void main(String[] args) {
        int rows = 5;
        for (int i = rows; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

输出结果：

* * * * * 
* * * * 
* * * 
* * 
*

示例 4：打印九九乘法表

public class九九乘法表Example {
    public static void main(String[] args) {
        System.out.println("九九乘法表:");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= 9; j++) {
                System.out.print(i + " × " + j + " = " + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}

嵌套循环的应用场景

1. 二维数组的遍历

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

2. 组合问题

// 打印所有可能的两位数组合
for (int i = 1; i <= 9; i++) {
    for (int j = 0; j <= 9; j++) {
        System.out.println(i + "" + j);
    }
}

3. 模式打印

// 打印菱形
int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = n; j > i; j--) {
        System.out.print(" ");
    }
    for (int j = 1; j <= 2 * i - 1; j++) {
        System.out.print("*");
    }
    System.out.println();
}
for (int i = n - 1; i >= 1; i--) {
    for (int j = n; j > i; j--) {
        System.out.print(" ");
    }
    for (int j = 1; j <= 2 * i - 1; j++) {
        System.out.print("*");
    }
    System.out.println();
}

示例：嵌套循环的使用

public class NestedLoopApplication {
    public static void main(String[] args) {
        // 打印乘法表
        System.out.println("Multiplication Table:");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " × " + i + " = " + (i * j) + "\t");
            }
            System.out.println();
        }
        
        // 打印菱形
        System.out.println("\nDiamond:");
        int n = 5;
        for (int i = 1; i <= n; i++) {
            for (int j = n; j > i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        for (int i = n - 1; i >= 1; i--) {
            for (int j = n; j > i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        
        // 计算二维数组的和
        System.out.println("\nSum of 2D array:");
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        int sum = 0;
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                sum += matrix[i][j];
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("Sum: " + sum);
    }
}

常见问题

1. 无限循环

症状：嵌套循环陷入无限循环

解决方案：确保每个循环的条件表达式最终会变为 false

2. 循环次数错误

症状：嵌套循环的执行次数不符合预期

解决方案：仔细检查每个循环的条件表达式和更新表达式

3. 性能问题

症状：嵌套循环导致程序运行缓慢

解决方案：尽量减少嵌套循环的层数，优化循环条件，避免不必要的计算

4. 代码可读性差

症状：嵌套循环层次过多，代码难以理解

解决方案：减少嵌套层次，将复杂的循环逻辑提取为方法

总结

嵌套循环是 Java 中一种常见的编程结构，它允许在一个循环中包含另一个循环。嵌套循环在处理二维数据、模式打印、组合问题等场景中非常有用。

在使用嵌套循环时，需要注意：

• 确保每个循环的条件表达式最终会变为 false，避免无限循环
• 仔细检查循环的执行次数，确保符合预期
• 注意性能问题，尽量减少嵌套层次
• 保持代码的可读性，避免过度嵌套

通过合理使用嵌套循环，可以解决各种复杂的编程问题，提高程序的灵活性和表现力。