4 / 10

Java循环结构 | 自在学

Java循环结构

在之前的编程学习中，我们编写的程序都是按照顺序一条一条执行的，每个语句只执行一次。但是在实际编程中，我们经常需要让某些代码重复执行多次。比如，我们需要打印100次“Hello World”，或者需要计算1到100的和，或者需要读取用户输入的多个数据。

这种让代码重复执行的结构在编程中称为循环。循环是编程中最基本也是最重要的概念之一，它让计算机能够不知疲倦地重复执行相同的任务。

Java循环结构

递增和递减运算符

在正式学习循环结构之前，我们需要先掌握递增（increment）和递减（decrement）运算符的用法。这两个运算符在循环语句中非常常见，通常用于控制循环变量的变化。

递增运算符++的作用是将变量的值增加1，相当于number = number + 1。递减运算符--则是将变量的值减少1，相当于number = number - 1。这两个运算符可以写在变量的前面（前缀）或后面（后缀），在循环体中经常用来让循环变量逐步增加或减少，从而控制循环的次数。例如，在for循环或while循环中，我们常常会看到如下写法：

|
for (int i = 0; i < 100; i++) {
    System.out.println("Hello World");
}

递增和递减运算符的使用

|
public class IncrementDecrementDemo {
    public static void main(String[] args) {
        int number = 5;
        
        System.out.println("初始值: " + number);
        
        // 使用递增运算符
        number++;
        System.out.println("递增后: " + number);
        
        // 使用递减运算符
        number--;
        System.out.println("递减后: " + number);
        
        // 前缀和后缀的区别
        int a = 5;
        int b = 5;
        
        System.out.println("前缀递增: " + (++a));  // 先递增，再使用
        System.out.println("后缀递增: " + (b++));  // 先使用，再递增
        
        System.out.println("a的值: " + a);
        System.out.println("b的值: " + b);
    }
}

运行这个程序会输出：

|
初始值: 5
递增后: 6
递减后: 5
前缀递增: 6
后缀递增: 5
a的值: 6
b的值: 6

前缀和后缀的区别

递增和递减运算符有两种使用方式：前缀和后缀。

前缀方式（++number）：先递增变量的值，然后使用递增后的值。 后缀方式（number++）：先使用变量的当前值，然后递增变量的值。

让我们看一个更详细的例子：

|
public class PrefixPostfixDemo {
    public static void main(String[] args) {
        int x = 10;
        int y = 10;
        
        // 前缀递增
        System.out.println("前缀递增: " + ++x);  // 输出11
        System.out.println("x的值: " + x);       // 输出11

运行这个程序会输出：

|
前缀递增: 11
x的值: 11
后缀递增: 10
y的值: 11

while循环

while循环是Java中最基本、最常用的循环结构之一。它的核心思想是：在每次循环开始前，先判断一个条件表达式是否为真。如果条件为真（即条件表达式的结果为true），就会执行循环体内的代码块；执行完毕后，再次判断条件是否为真，如此反复，直到条件为假（即条件表达式的结果为false）时，循环才会终止，程序会继续执行循环后面的代码。

也就是说，while循环在每次循环前都会进行条件判断，只有满足条件时才会进入循环体，否则直接跳出循环。这种结构非常适合用于事先无法确定循环次数、但需要根据某个条件反复执行某段代码的场景。

while循环

while循环的语法

|
while (条件表达式) {
    // 循环体 - 需要重复执行的代码
}

第一个while循环示例

让我们看一个简单的例子，打印数字1到5：

|
public class WhileLoopDemo {
    public static void main(String[] args) {
        int number = 1;
        
        while (number <= 5) {
            System.out.println("数字: " + number);
            number++;
        }
        
        System.out.println("循环结束"

运行这个程序会输出：

|
数字: 1
数字: 2
数字: 3
数字: 4
数字: 5
循环结束

理解while循环的执行流程

让我们详细分析一下while循环是如何工作的：

初始化：设置循环变量number的初始值为1
条件检查：检查number <= 5是否为真
执行循环体：如果条件为真，执行大括号内的代码
更新循环变量：执行number++，将number的值增加1
重复步骤2-4：直到条件变为假
结束循环：当条件为假时，跳出循环，继续执行后面的代码

循环控制变量

在上面的例子中，number变量被称为循环控制变量，它控制着循环的执行次数。循环控制变量通常需要：

初始化：在循环开始前设置初始值
条件检查：在循环条件中使用
更新：在循环体内改变其值

无限循环的危险

如果循环条件永远不会变为假，循环就会无限执行下去，这称为无限循环。例如：

|
int number = 1;
while (number <= 5) {
    System.out.println("数字: " + number);
    // 忘记更新number，导致无限循环
}

这个循环会无限打印"数字: 1"，因为number的值永远不会改变。

使用while循环进行输入验证

while循环特别适合用于输入验证。我们可以让用户重复输入，直到输入正确的数据为止。

|
import java.util.Scanner;
 
public class InputValidationDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int score;
        
        System.out.print("请输入成绩（0-100）: ");
        score = scanner.nextInt();
        
        // 验证输入是否有效
        while (score

do-while循环

do-while循环是while循环的一种变体。与while循环不同，do-while循环无论条件是否成立，都会先执行一次循环体，然后再判断条件是否满足，决定是否继续执行后续循环。也就是说，do-while循环至少会执行一次循环体。其执行流程如下：

先执行一次循环体中的代码；
然后判断循环条件是否为真；
如果条件为真，则继续执行循环体，再次判断条件；
如果条件为假，则循环结束。

这种结构特别适合需要“至少执行一次”的场景，比如菜单选择、用户输入验证等。相比之下，while循环是在每次循环前先判断条件，只有条件为真时才会执行循环体，因此如果初始条件不满足，循环体一次都不会执行。

do-while循环的语法

|
do {
    // 循环体
} while (条件表达式);

do-while循环示例

|
import java.util.Scanner;
 
public class DoWhileDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        char choice;
        
        do {
            System.out.println("=== 菜单 ===");
            System.out.println("1. 查看信息");
            System.out.println(

while循环和do-while循环的区别

特性	while循环	do-while循环
条件检查时机	先检查条件，再执行循环体	先执行循环体，再检查条件
最少执行次数	0次（如果初始条件为假）	1次（至少执行一次）
适用场景	不确定是否需要执行循环	至少需要执行一次循环

for循环

for循环是Java中最常用、最基础的循环结构之一。它非常适合用于需要重复执行固定次数操作的场景，比如遍历数组、统计数据、批量处理等。 for循环的最大特点是将初始化、条件判断和变量更新这三个关键步骤都写在循环头部的一行代码中，使得循环结构更加紧凑、清晰。其基本语法如下：

for循环的语法

|
for (初始化; 条件检查; 更新) {
    // 循环体
}

for循环的三个部分

初始化：在循环开始前执行一次，通常用来初始化循环变量
条件检查：每次循环前检查，如果为真则继续循环
更新：每次循环后执行，通常用来更新循环变量

基本for循环示例

|
public class ForLoopDemo {
    public static void main(String[] args) {
        // 打印1到10的数字
        for (int i = 1; i <= 10; i++) {
            System.out.print(i + " ");
        }
        System.out.println();
        
        // 打印1到10的平方
        System.out.

运行这个程序会输出：

|
1 2 3 4 5 6 7 8 9 10 
数字	平方
------------
1	1
2	4
3	9
4	16
5	25
6	36
7	49
8	64
9	81
10	100

for循环的变体

for循环有多种使用方式：

|
public class ForLoopVariants {
    public static void main(String[] args) {
        // 倒序循环
        System.out.println("倒序打印:");
        for (int i = 10; i >= 1; i--) {
            System.out.print(i + " ");
        }
        System.out.println

运行这个程序会输出：

|
倒序打印:
10 9 8 7 6 5 4 3 2 1 
偶数:
2 4 6 8 10 12 14 16 18 20 
1到100的和: 5050

用户控制的for循环

我们也可以让用户决定循环的次数：

|
import java.util.Scanner;
 
public class UserControlledForLoop {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入要打印的数字个数: ");
        int count = scanner.nextInt();
        
        System.out.println("打印" + count

累计和哨兵值

累计的概念

累计（accumulation）是指将一组数字逐个相加，得到它们的总和的过程。在编程中，累计通常通过在循环中不断地把每个数字加到一个变量上来实现。例如，计算一组学生的总成绩、求一系列数据的平均值、统计某个范围内所有整数的和等，都是累计的典型应用。累计不仅可以用于求和，还可以用于其他类似的累加操作，比如累计乘积（连乘）、累计计数等。在实际编程中，累计操作经常与循环结构结合使用，通过每次循环更新累计变量，最终得到所需的结果。

使用循环计算累计和

|
import java.util.Scanner;
 
public class RunningTotalDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入要计算的数字个数: ");
        int count = scanner.nextInt();
        
        double total = 0.0;  // 累计变量，初始化为0

哨兵值

在实际编程中，有些情况下我们无法提前知道需要输入多少个数据，比如用户输入一组成绩或数字。这时，我们可以使用“哨兵值”（sentinel value）来标记输入的结束。哨兵值是一个特殊的数值，通常选用一个不可能作为正常数据出现的值（比如-1），当用户输入这个值时，程序就知道数据输入已经结束，从而跳出循环。通过这种方式，用户可以根据实际需要输入任意数量的数据，而不必事先指定数据的个数。

|
import java.util.Scanner;
 
public class SentinelValueDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("请输入成绩（输入-1结束）:");
        
        int score;
        int total = 0;
        int count = 0

嵌套循环

嵌套循环的概念

嵌套循环是指在一个循环体内部又包含了另一个完整的循环结构。也就是说，外层循环每执行一次，内层循环就会完整地执行一遍。通过这种方式，可以实现对多维数据的遍历和处理。

嵌套循环在实际编程中非常常见，尤其是在需要处理二维或多维数据结构时，比如打印表格、处理矩阵、绘制图案等。例如，打印九九乘法表时，外层循环控制行数，内层循环控制每一行中要输出的内容。

需要注意的是，嵌套循环的执行次数等于外层循环次数乘以内层循环次数，因此在设计嵌套循环时要注意循环条件，避免出现不必要的性能问题或死循环。

基本嵌套循环示例

|
public class NestedLoopDemo {
    public static void main(String[] args) {
        // 打印乘法表
        System.out.println("乘法表:");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {

运行这个程序会输出：

|
乘法表:
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	
 
矩形图案:
**********
**********
**********
**********
**********
 
三角形图案:
*
**
***
****
*****

嵌套循环的实际应用

|
import java.util.Scanner;
 
public class StudentGradesDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入学生人数: ");
        int students = scanner.nextInt();
        
        System.out.print("请输入每门课程的数量: ");

break和continue语句

break语句

在前面的switch语句中，我们已经见过break语句的用法。在循环结构中，break语句同样非常重要。它的作用是立即终止当前所在的循环，无论循环条件是否还为真，遇到break后都会直接跳出循环体，程序会从循环后面的第一条语句继续执行。

通常，break语句用于以下几种场景：

在循环中提前结束循环，比如在查找满足某个条件的数据时，一旦找到就不再继续循环；
在嵌套循环中，可以配合标签（label）使用，跳出多层循环（进阶用法）。

需要注意的是，break只会跳出最近一层的循环。如果有多层嵌套循环，break只会终止它所在的那一层。

举个例子：假设我们要在1到100的数字中查找第一个能被7整除的数，找到后就停止循环，这时就可以用break来实现提前结束循环。这样可以避免不必要的重复计算，提高程序效率。

|
public class BreakDemo {
    public static void main(String[] args) {
        // 查找第一个能被7整除的数
        for (int i = 1; i <= 100; i++) {
            if (i % 7 == 0) {
                System.out.println("找到第一个能被7整除的数: " + i);
                break;

continue语句

continue语句的作用是在循环中立即跳过本次循环剩余的所有语句，直接进入下一次循环条件的判断。当程序执行到continue时，会立刻停止当前循环体中continue后面的代码，开始下一轮循环（如果循环条件仍然成立）。
常见用法包括：在满足某些条件时，不执行本次循环的后续操作，而是直接进行下一次循环。例如，过滤掉不需要处理的数据、跳过某些特殊情况等。

举例说明：在一个for循环中，如果遇到某个特定的值，就跳过本次循环，不执行后续语句，而是直接进入下一个循环周期。

|
public class ContinueDemo {
    public static void main(String[] args) {
        // 打印1到10中除了5以外的所有数
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                continue;  // 跳过5，继续下一次循环
            }
            System.out.print(i + " "

运行这个程序会输出：

|
1 2 3 4 6 7 8 9 10 
1到100中奇数的和: 2500

文件输入输出

在实际编程中，数据的持久化是非常重要的。我们常常需要将程序运行过程中产生的数据保存到磁盘文件中，这样即使程序关闭或计算机重启，数据依然不会丢失。文件操作不仅可以让我们将数据写入文件，还可以在需要时从文件中读取数据，实现数据的长期保存和后续处理。

例如，学生成绩管理系统会把每个学生的成绩保存到文件中，方便以后查询和统计；日志系统会把运行信息写入日志文件，便于排查问题。通过文件输入输出（I/O）操作，程序能够与外部世界进行数据交换，极大地扩展了应用的功能和实用性。

文件输入输出

写入文件

|
import java.io.*;
 
public class FileWriteDemo {
    public static void main(String[] args) throws IOException {
        // 创建PrintWriter对象来写入文件
        PrintWriter outputFile = new PrintWriter("students.txt");
        
        // 写入学生信息
        outputFile.println("张三,85,90,88");
        outputFile.println("李四,92,87,95"

读取文件

|
import java.io.*;
import java.util.Scanner;
 
public class FileReadDemo {
    public static void main(String[] args) throws IOException {
        // 创建File对象
        File file = new File("students.txt");
        
        // 检查文件是否存在
        if (!file.exists()) {
            System.out.

文件操作的实际应用

|
import java.io.*;
import java.util.Scanner;
 
public class GradeManager {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入学生姓名: ");
        String name = scanner.nextLine();

随机数生成

使用Random类

在Java中，如果你需要生成随机数，可以使用Random类。Random类属于java.util包，能够生成各种类型的随机数，包括整数、浮点数等。它常用于游戏开发（比如掷骰子、抽奖）、模拟实验、数据加密等需要不确定性或模拟现实随机性的场景。

使用Random类时，通常需要先创建一个Random对象，然后调用其方法来生成不同类型的随机数。例如，nextInt()方法可以生成一个随机整数，nextDouble()方法可以生成一个0.0到1.0之间的随机小数。你还可以通过指定参数来生成特定范围内的随机数。

下面将通过代码示例详细介绍如何使用Random类生成不同类型和范围的随机数。

|
import java.util.Random;
 
public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        
        // 生成随机整数
        System.out.println("随机整数:");
        for (int i = 0; i < 5; i++) {
            int

随机数应用示例

|
import java.util.Random;
import java.util.Scanner;
 
public class NumberGuessingGame {
    public static void main(String[] args) {
        Random random = new Random();
        Scanner scanner = new Scanner(System.in);
        
        // 生成1到100之间的随机数
        int targetNumber = random.nextInt(100) + 1

选择循环类型

三种循环的比较

循环类型	适用场景	特点
while循环	不确定循环次数，需要先检查条件	先检查条件，再执行循环体
do-while循环	至少需要执行一次循环	先执行循环体，再检查条件
for循环	知道循环的确切次数	初始化、条件检查、更新都在一行

选择建议

使用while循环：当你不确定循环次数，或者需要根据条件决定是否执行循环时
使用do-while循环：当你需要至少执行一次循环体时
使用for循环：当你知道循环的确切次数，或者需要遍历数组、集合时

习题

Java中用于实现循环结构的语句有哪些？

while循环的执行流程是？

for循环的三个部分（初始化、条件检查、更新）的执行顺序是？

在循环中，continue语句的作用是？

嵌套循环的总执行次数如何计算？

在for循环中，以下哪种方式可以用于更新循环变量i？

判断以下代码的输出结果：

|
int i = 1;
while (i <= 5) {
    System.out.print(i + " ");
    i++;
}

8. while循环基础

编写一个程序，使用while循环打印数字1到10。

|
public class WhileLoopDemo {
    public static void main(String[] args) {
        int i = 1;
        
        while (i <= 10) {
            System.out.print(i + " ");
            i++;
        }
        System.out.println();
    }
}

9. for循环计算和

编写一个程序，使用for循环计算1到100的和。

|
public class SumCalculation {
    public static void main(String[] args) {
        int sum = 0;
        
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        
        System.out.println("1到100的和是: "

10. 嵌套循环打印图案

编写一个程序，使用嵌套循环打印以下三角形图案：

|
*
**
***
****
*****

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

11. 输入验证练习

编写一个程序，要求用户输入一个1到10之间的数字，如果输入错误则重新输入，直到输入正确为止。

|
import java.util.Scanner;
 
public class InputValidation {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int number;
        
        do {
            System.out.print("请输入一个1到10之间的数字: ");
            number = scanner.nextInt();
            
            if

12. 累计计算练习

编写一个程序，计算用户输入的5个数字的平均值。

|
import java.util.Scanner;
 
public class AverageCalculation {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double sum = 0.0;
        
        System.out.println("请输入5个数字：");
        for (int i = 1; i <=