跳到主要内容

Java 嵌套循环

什么是嵌套循环？​

嵌套循环是指在一个循环体内再定义一个循环的结构。简单来说，就是循环中还有循环。这种结构在处理多维数据（如二维数组）或需要按照特定模式进行重复操作时特别有用。

在Java中，我们可以嵌套任何类型的循环（for、while、do-while），且嵌套的层数理论上没有限制，但通常不建议超过三层，否则代码可读性会大大降低。

嵌套循环的基本语法​

以下是嵌套循环的一般语法结构：

// 外层循环
for (初始化; 条件; 递增/递减) {
    // 外层循环体代码
    
    // 内层循环
    for (初始化; 条件; 递增/递减) {
        // 内层循环体代码
    }
    
    // 外层循环体的其他代码
}

嵌套循环的执行流程​

嵌套循环的执行过程可以想象成时钟的运行：

  • 外层循环就像小时指针，每走一步（一次迭代）
  • 内层循环则像分钟指针，需要完整地走一圈（完成所有迭代）
理解执行次数

如果外层循环执行n次，内层循环执行m次，那么内层循环体的代码总共会执行n×m次。

嵌套循环示例​

示例1：简单的乘法表​

下面是使用嵌套循环打印九九乘法表的例子：

public class MultiplicationTable {
    public static void main(String[] args) {
        // 外层循环控制行数
        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();
        }
    }
}

输出结果：

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 StarPattern {
    public static void main(String[] args) {
        int rows = 5;
        
        // 外层循环控制行数
        for (int i = 1; i <= rows; i++) {
            // 内层循环打印空格
            for (int j = rows - i; j >= 1; j--) {
                System.out.print(" ");
            }
            
            // 内层循环打印星号
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*");
            }
            
            System.out.println();
        }
    }
}

输出结果：

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

不同类型循环的嵌套​

嵌套循环可以混合使用不同类型的循环结构：

for循环嵌套在while循环内​

public class MixedLoops {
    public static void main(String[] args) {
        int i = 1;
        
        // 外层while循环
        while (i <= 3) {
            System.out.println("外层循环执行第" + i + "次");
            
            // 内层for循环
            for (int j = 1; j <= 2; j++) {
                System.out.println("  内层循环执行第" + j + "次");
            }
            
            i++;
            System.out.println(); // 添加空行
        }
    }
}

输出结果：

外层循环执行第1次
  内层循环执行第1次
  内层循环执行第2次

外层循环执行第2次
  内层循环执行第1次
  内层循环执行第2次

外层循环执行第3次
  内层循环执行第1次
  内层循环执行第2次

实际应用场景​

1. 多维数组操作​

嵌套循环最常见的应用就是处理二维数组：

public class TwoDimensionalArray {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        System.out.println("打印矩阵元素：");
        // 外层循环遍历行
        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(); // 换行
        }
    }
}

输出结果：

打印矩阵元素：
1 2 3 
4 5 6 
7 8 9

2. 日历打印​

使用嵌套循环可以打印日历：

public class CalendarExample {
    public static void main(String[] args) {
        int month = 9; // 假设是9月
        int daysInMonth = 30; // 9月有30天
        int startDay = 5; // 假设9月1日是星期五
        
        String[] weekdays = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
        
        // 打印星期标题
        for (String day : weekdays) {
            System.out.print(day + "\t");
        }
        System.out.println();
        
        // 打印前导空格
        for (int i = 0; i < startDay; i++) {
            System.out.print("\t");
        }
        
        // 打印日期
        for (int day = 1; day <= daysInMonth; day++) {
            System.out.print(day + "\t");
            
            // 如果是周六，换行
            if ((day + startDay) % 7 == 0) {
                System.out.println();
            }
        }
    }
}

3. 算法实现​

很多经典算法如冒泡排序也用到了嵌套循环：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        
        System.out.print("排序前: ");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        
        // 冒泡排序算法
        for (int i = 0; i < arr.length - 1; i++) {
            // 内层循环比较相邻元素
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        
        System.out.print("\n排序后: ");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

输出结果：

排序前: 64 34 25 12 22 11 90 
排序后: 11 12 22 25 34 64 90

嵌套循环的性能考虑​

嵌套循环会显著增加程序的时间复杂度：

注意事项

当处理大量数据时，嵌套循环可能导致性能问题。尽量避免不必要的循环嵌套，特别是对于数据量大的应用。

总结​

嵌套循环是Java编程中一个强大的工具，能够帮助我们解决复杂的重复任务和多维数据处理问题：

  1. 嵌套循环是指在一个循环内部包含另一个循环
  2. 最常见的应用包括处理二维数组、打印图案和实现各种算法
  3. 每当外层循环执行一次，内层循环会完整执行一轮
  4. 可以混合使用不同类型的循环（for、while、do-while）
  5. 嵌套层数越多，时间复杂度越高，需要注意性能问题

练习题​

为了巩固所学知识，尝试完成以下练习：

  1. 使用嵌套循环打印一个10x10的乘法表
  2. 使用嵌套循环打印一个倒三角形图案
  3. 编写程序使用嵌套循环找出100以内的所有质数
  4. 使用嵌套循环实现矩阵转置（行变列，列变行）
  5. 挑战：使用嵌套循环打印出菱形图案

通过练习这些问题，你将更好地掌握嵌套循环的应用技巧，从而能够解决更复杂的编程问题。

延伸阅读​

  • 学习Java中的递归，它有时可以替代深层嵌套循环
  • 了解Java 8引入的Stream API，它提供了更现代且可读性更强的方式来处理集合数据
  • 研究时间复杂度分析，以便更好地理解嵌套循环对程序性能的影响