【Java笔记】第4章：深入学习循环结构

---

↓
上期回顾: 【Java笔记】第3章：深入学习分支结构
个人主页：C_GUIQU
归属专栏：【Java学习】
↑

前言

各位小伙伴大家好！上期小编给大家讲解了Java中的分支结构，接下来讲讲循环！

1. 循环的理解

【理解】依据条件，重复且有规律。
【组成】循环变量的初始化、循环条件、循环变量的改变、循环体。
【分类】while循环、do…while循环、for循环。

2. while循环

【语法】

// 循环变量的初始化
while(循环条件){
   // 循环体(重复执行的功能代码)
   // 循环变量的改变
}

【示例】计算从 1 加到 10 的和

public class WhileExample {
    public static void main(String[] args) {
        int sum = 0; // 定义一个变量用于存储和
        int i = 1; // 定义一个循环变量

        while (i <= 10) { // 当 i 小于等于 10 时执行循环体内的语句
            sum += i; // 将 i 的值加到 sum 上
            i++; // 将 i 的值增加 1
        }

        // 循环结束后打印结果
        System.out.println("1 到 10 的和为: " + sum);
    }
}

3. do…while循环

【语法】

// 循环变量的初始化
do{
   // 循环体
   // 循环变量的改变
}while(循环条件); // 分号不能省略

【特点】先执行，再判断。
【示例】计算从 1 加到 10 的和

public class DoWhileExample {
    public static void main(String[] args) {
        int sum = 0; // 定义一个变量用于存储和
        int i = 1; // 定义一个循环变量

        do {
            sum += i; // 将 i 的值加到 sum 上
            i++; // 将 i 的值增加 1
        } while (i <= 10); // 当 i 小于等于 10 时继续执行循环体内的语句

        // 循环结束后打印结果
        System.out.println("1 到 10 的和为: " + sum);
    }
}

4. for循环

【语法】

for(循环变量的初始化;循环条件;循环变量的改变){
   // 循环体
}

【执行原理】

【示例1】打印从 1 到 10 的数字

public class ForLoopExample {
    public static void main(String[] args) {
        // 使用 for 循环打印从 1 到 10 的数字
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

【示例2】遍历数组

public class ForLoopArrayExample {
    public static void main(String[] args) {
        // 定义一个整型数组
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // 使用 for 循环遍历数组并打印每个元素
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

【循环的总结】
while循环和for循环特点：先判断，再执行。
do…while循环特点：先执行，再判断。
当循环次数不确定时，建议使用while循环。
当循环的次数明确时，建议使用for循环。

5. 循环的控制语句

在 Java 中，循环的控制语句允许你改变循环的正常流程。主要有三种控制语句：break、continue 和 return。

1. break 语句：用于立即退出最内层的循环，无论循环条件是否为真。break 语句也可以用于 switch 语句，用于退出 switch 语句。

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break; // 当 i 等于 5 时，退出循环
    }
    System.out.println(i); // 只打印 1 到 4
}

2. continue 语句：用于跳过当前循环的剩余部分，并开始下一次循环迭代。

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        continue; // 当 i 等于 5 时，跳过这次迭代
    }
    System.out.println(i); // 打印 1 到 10，但不包括 5
}

3. return 语句：用于从方法中返回一个值（如果方法有返回类型的话），并立即退出该方法。如果在循环内使用 return，它将导致整个方法立即结束，从而退出循环。

public static void printNumbers(int max) {
    for (int i = 1; i <= max; i++) {
        if (i == 5) {
            return; // 当 i 等于 5 时，退出方法
        }
        System.out.println(i); // 只打印 1 到 4
    }
}

在编写循环时，这些控制语句可以用来根据特定的条件来控制循环的执行流程。需要注意的是，过度使用这些控制语句可能会导致代码难以理解和维护，因此应该谨慎使用。

6. 循环的嵌套

循环的嵌套是指在一个循环内部再嵌套另一个循环。在 Java 中，你可以嵌套 for、while、do...while 循环。
在实际开发中，for循环用的最多，接下来举三个for循环嵌套的例子。

【打印一个乘法表】

public class NestedLoopsExample {
    public static void main(String[] args) {
        int rows = 10;
        int columns = 10;
        // 外层循环控制行
        for (int i = 1; i <= rows; i++) {
            // 内层循环控制列
            for (int j = 1; j <= columns; j++) {
                // 打印乘法表的一个元素
                System.out.print(i * j + "\t");
            }
            // 每打印完一行后换行
            System.out.println();
        }
    }
}

在这个例子中，外层 for 循环用于控制行数，内层 for 循环用于控制每行中的列数。内层循环会在外层循环的每次迭代中完整执行。这样，内层循环的每次迭代都会打印出当前行和列的乘积。

【打印星号图案】
这个例子使用嵌套的 for 循环来打印一个金字塔形状的星号图案。

public class StarPatternExample {
    public static void main(String[] args) {
        int rows = 5;
        // 外层循环控制行数
        for (int i = 1; i <= rows; i++) {
            // 打印空格，形成左对齐的金字塔
            for (int j = 1; j <= rows - i; j++) {
                System.out.print(" ");
            }
            // 内层循环控制每行星号的个数
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            // 每打印完一行后换行
            System.out.println();
        }
    }
}

运行这个程序会输出以下图案：

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

【遍历二维数组】
这个例子使用嵌套的 for 循环来遍历一个二维数组并打印其元素。

public class TwoDimensionalArrayExample {
    public static void main(String[] args) {
        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();
        }
    }
}

运行这个程序会输出二维数组的所有元素，按照它们在数组中的排列：

1 2 3
4 5 6
7 8 9

在这两个例子中，嵌套循环用于处理更复杂的逻辑，比如在第一个例子中创建一个基于行和列的图形，在第二个例子中遍历一个二维数据结构。嵌套循环是处理这类问题的有力工具。

嵌套循环可以用于多种场景，比如处理二维数组、图形和图像的渲染、复杂的数据结构遍历等。在设计嵌套循环时，重要的是要确保内外层循环的逻辑是正确的，并且要考虑到循环的终止条件，以避免无限循环。

结语

以上就是小编对Java中循环的讲解。
如果觉得小编讲的还可以，还请一键三连。互三必回！
持续更新中~！