跳到主要内容

Java 嵌套循环

什么是嵌套循环?

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

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

嵌套循环的基本语法

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

java
// 外层循环
for (初始化; 条件; 递增/递减) {
// 外层循环体代码

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

// 外层循环体的其他代码
}

嵌套循环的执行流程

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

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

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

嵌套循环示例

示例1:简单的乘法表

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

java
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:打印星号图案

使用嵌套循环来打印三角形图案:

java
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循环内

java
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. 多维数组操作

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

java
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. 日历打印

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

java
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. 算法实现

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

java
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,它提供了更现代且可读性更强的方式来处理集合数据
  • 研究时间复杂度分析,以便更好地理解嵌套循环对程序性能的影响