自在学
分类课程AI导师价格
分类课程AI导师价格
Java的决策结构
4 / 10
Java方法(函数)
自在学

© 2025 - 2026 自在学，保留所有权利。

公网安备湘公网安备43020302000292号 | 湘ICP备2025148919号-1

关于我们隐私政策使用条款

© 2025 自在学，保留所有权利。

公网安备湘公网安备43020302000292号湘ICP备2025148919号-1

编程JavaJava循环结构

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
        
        // 后缀递增
        System.out.println("后缀递增: " + y++);  // 输出10
        System.out.println("y的值: " + y);       // 输出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循环是如何工作的：

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

循环控制变量

在上面的例子中，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 < 0 || score > 100) {
            System.out.println("成绩无效！请输入0到100之间的数字。");
            System.out.print("请重新输入成绩: ");
            score = scanner.nextInt();
        }
        
        System.out.println("输入的成绩是: " + score);
        scanner.close();
    }
}

do-while循环

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

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

这种结构特别适合需要“至少执行一次”的场景，比如菜单选择、用户输入验证等。相比之下，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("2. 修改信息");
            System.out.println("3. 退出");
            System.out.print("请选择操作（1-3）: ");
            
            choice = scanner.next().charAt(0);
            
            switch (choice) {
                case '1':
                    System.out.println("显示信息...");
                    break;
                case '2':
                    System.out.println("修改信息...");
                    break;
                case '3':
                    System.out.println("退出程序");
                    break;
                default:
                    System.out.println("无效选择，请重新输入");
            }
        } while (choice != '3');
        
        scanner.close();
    }
}

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

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

for循环

for循环

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

for循环的语法

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

for循环的三个部分

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

基本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.println("数字\t平方");
        System.out.println("------------");
        for (int i = 1; i <= 10; i++) {
            System.out.println(i + "\t" + (i * i));
        }
    }
}

运行这个程序会输出：

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();
        
        // 步长为2的循环
        System.out.println("偶数:");
        for (int i = 2; i <= 20; i += 2) {
            System.out.print(i + " ");
        }
        System.out.println();
        
        // 在循环外声明变量
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1到100的和: " + sum);
    }
}

运行这个程序会输出：

倒序打印:
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 + "个数字:");
        for (int i = 1; i <= count; i++) {
            System.out.print(i + " ");
        }
        
        scanner.close();
    }
}

累计和哨兵值

累计的概念

累计（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
        
        for (int i = 1; i <= count; i++) {
            System.out.print("请输入第" + i + "个数字: ");
            double number = scanner.nextDouble();
            total += number;  // 将数字加到累计和中
        }
        
        System.out.println("总和: " + total);
        System.out.println("平均值: " + (total / count));
        
        scanner.close();
    }
}

哨兵值

在实际编程中，有些情况下我们无法提前知道需要输入多少个数据，比如用户输入一组成绩或数字。这时，我们可以使用“哨兵值”（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;
        
        // 获取第一个成绩
        System.out.print("请输入成绩: ");
        score = scanner.nextInt();
        
        // 使用哨兵值-1来结束循环
        while (score != -1) {
            total += score;
            count++;
            
            System.out.print("请输入成绩: ");
            score = scanner.nextInt();
        }
        
        if (count > 0) {
            System.out.println("总成绩: " + total);
            System.out.println("平均成绩: " + (double) total / count);
        } else {
            System.out.println("没有输入任何成绩");
        }
        
        scanner.close();
    }
}

嵌套循环

嵌套循环的概念

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

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

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

基本嵌套循环示例

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++) {
                System.out.print(j + "×" + i + "=" + (i * j) + "\t");
            }
            System.out.println();
        }
        
        // 打印矩形图案
        System.out.println("\n矩形图案:");
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 10; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        
        // 打印三角形图案
        System.out.println("\n三角形图案:");
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            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	
 
矩形图案:
**********
**********
**********
**********
**********
 
三角形图案:
*
**
***
****
*****

嵌套循环的实际应用

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("请输入每门课程的数量: ");
        int courses = scanner.nextInt();
        
        // 外层循环处理每个学生
        for (int student = 1; student <= students; student++) {
            System.out.println("\n学生 " + student + " 的成绩:");
            System.out.println("----------------");
            
            double total = 0.0;
            
            // 内层循环处理每门课程
            for (int course = 1; course <= courses; course++) {
                System.out.print("课程 " + course + " 的成绩: ");
                double score = scanner.nextDouble();
                total += score;
            }
            
            double average = total / courses;
            System.out.printf("学生 %d 的平均成绩: %.2f\n", student, average);
        }
        
        scanner.close();
    }
}

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;  // 找到后立即退出循环
            }
        }
        
        // 输入验证示例
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        int number;
        
        while (true) {
            System.out.print("请输入一个正数: ");
            number = scanner.nextInt();
            
            if (number > 0) {
                System.out.println("输入正确: " + number);
                break;  // 输入正确后退出循环
            } else {
                System.out.println("输入错误，请重新输入");
            }
        }
        
        scanner.close();
    }
}

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 + " ");
        }
        System.out.println();
        
        // 计算1到100中奇数的和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                continue;  // 跳过偶数
            }
            sum += i;
        }
        System.out.println("1到100中奇数的和: " + sum);
    }
}

运行这个程序会输出：

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");
        outputFile.println("王五,78,82,80");
        
        // 关闭文件
        outputFile.close();
        
        System.out.println("数据已写入文件");
    }
}

读取文件

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.println("文件不存在");
            return;
        }
        
        // 创建Scanner对象来读取文件
        Scanner inputFile = new Scanner(file);
        
        System.out.println("学生信息:");
        System.out.println("姓名\t语文\t数学\t英语");
        System.out.println("------------------------");
        
        // 逐行读取文件内容
        while (inputFile.hasNext()) {
            String line = inputFile.nextLine();
            String[] parts = line.split(",");
            
            System.out.printf("%s\t%s\t%s\t%s\n", 
                parts[0], parts[1], parts[2], parts[3]);
        }
        
        // 关闭文件
        inputFile.close();
    }
}

文件操作的实际应用

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();
        
        System.out.print("请输入语文成绩: ");
        int chinese = scanner.nextInt();
        
        System.out.print("请输入数学成绩: ");
        int math = scanner.nextInt();
        
        System.out.print("请输入英语成绩: ");
        int english = scanner.nextInt();
        
        // 计算平均分
        double average = (chinese + math + english) / 3.0;
        
        // 写入文件
        PrintWriter outputFile = new PrintWriter("grades.txt");
        outputFile.println(name + "," + chinese + "," + math + "," + english + "," + average);
        outputFile.close();
        
        System.out.println("成绩已保存到文件");
        System.out.printf("平均分: %.2f\n", average);
        
        scanner.close();
    }
}

随机数生成

使用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 number = random.nextInt(100);  // 0到99之间的随机数
            System.out.print(number + " ");
        }
        System.out.println();
        
        // 生成随机小数
        System.out.println("随机小数:");
        for (int i = 0; i < 5; i++) {
            double number = random.nextDouble();  // 0.0到1.0之间的随机数
            System.out.printf("%.3f ", number);
        }
        System.out.println();
        
        // 生成指定范围的随机数
        System.out.println("1到10之间的随机数:");
        for (int i = 0; i < 5; i++) {
            int number = random.nextInt(10) + 1;  // 1到10之间的随机数
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

随机数应用示例

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;
        int attempts = 0;
        
        System.out.println("欢迎来到猜数字游戏！");
        System.out.println("我已经想好了一个1到100之间的数字");
        
        while (true) {
            System.out.print("请猜一个数字: ");
            int guess = scanner.nextInt();
            attempts++;
            
            if (guess == targetNumber) {
                System.out.println("恭喜你猜对了！");
                System.out.println("你总共猜了 " + attempts + " 次");
                break;
            } else if (guess < targetNumber) {
                System.out.println("太小了，再试试");
            } else {
                System.out.println("太大了，再试试");
            }
        }
        
        scanner.close();
    }
}

选择循环类型

三种循环的比较

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

选择建议

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

习题

  1. Java中用于实现循环结构的语句有哪些？
  1. while循环的执行流程是？
  1. for循环的三个部分（初始化、条件检查、更新）的执行顺序是？
  1. 在循环中，continue语句的作用是？
  1. 嵌套循环的总执行次数如何计算？
  1. 在for循环中，以下哪种方式可以用于更新循环变量i？
  1. 判断以下代码的输出结果：
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();
    }
}

输出结果：

1 2 3 4 5 6 7 8 9 10

说明：

  • 初始化循环变量i为1
  • 循环条件i <= 10控制循环次数
  • 每次循环后使用i++递增循环变量
  • 当i变为11时，条件为假，循环结束

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的和是: " + sum);
    }
}

输出结果：

1到100的和是: 5050

说明：

  • 使用sum变量累计和，初始化为0
  • for循环从1到100遍历
  • 每次循环将i加到sum中
  • 循环结束后输出总和

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("*");
            }
            System.out.println();
        }
    }
}

输出结果：

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

说明：

  • 外层循环控制行数（1到5行）
  • 内层循环控制每行打印的星号数量
  • 第i行打印i个星号
  • 每行结束后使用println()换行

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 (number < 1 || number > 10) {
                System.out.println("输入错误！请输入1到10之间的数字。");
            }
        } while (number < 1 || number > 10);
        
        System.out.println("输入正确！你输入的数字是: " + number);
        scanner.close();
    }
}

说明：

  • 使用do-while循环确保至少执行一次输入
  • 检查输入是否在1到10之间
  • 如果输入错误，提示用户并继续循环
  • 输入正确后退出循环并显示结果

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 <= 5; i++) {
            System.out.print("第" + i + "个数字: ");
            double number = scanner.nextDouble();
            sum += number;
        }
        
        double average = sum / 5.0;
        System.out.println("这5个数字的平均值是: " + average);
        
        scanner.close();
    }
}

说明：

  • 使用sum变量累计所有输入的数字
  • for循环执行5次，每次读取一个数字
  • 将每个数字加到sum中
  • 循环结束后计算平均值（总和除以数量）
  • 递增和递减运算符
    • 递增和递减运算符的使用
    • 前缀和后缀的区别
  • while循环
    • while循环的语法
    • 第一个while循环示例
    • 理解while循环的执行流程
    • 循环控制变量
    • 无限循环的危险
    • 使用while循环进行输入验证
  • do-while循环
    • do-while循环的语法
    • do-while循环示例
    • while循环和do-while循环的区别
  • for循环
    • for循环的语法
    • for循环的三个部分
    • 基本for循环示例
    • for循环的变体
    • 用户控制的for循环
  • 累计和哨兵值
    • 累计的概念
    • 使用循环计算累计和
    • 哨兵值
  • 嵌套循环
    • 嵌套循环的概念
    • 基本嵌套循环示例
    • 嵌套循环的实际应用
  • break和continue语句
    • break语句
    • continue语句
  • 文件输入输出
    • 写入文件
    • 读取文件
    • 文件操作的实际应用
  • 随机数生成
    • 使用Random类
    • 随机数应用示例
  • 选择循环类型
    • 三种循环的比较
    • 选择建议
  • 习题

目录

  • 递增和递减运算符
    • 递增和递减运算符的使用
    • 前缀和后缀的区别
  • while循环
    • while循环的语法
    • 第一个while循环示例
    • 理解while循环的执行流程
    • 循环控制变量
    • 无限循环的危险
    • 使用while循环进行输入验证
  • do-while循环
    • do-while循环的语法
    • do-while循环示例
    • while循环和do-while循环的区别
  • for循环
    • for循环的语法
    • for循环的三个部分
    • 基本for循环示例
    • for循环的变体
    • 用户控制的for循环
  • 累计和哨兵值
    • 累计的概念
    • 使用循环计算累计和
    • 哨兵值
  • 嵌套循环
    • 嵌套循环的概念
    • 基本嵌套循环示例
    • 嵌套循环的实际应用
  • break和continue语句
    • break语句
    • continue语句
  • 文件输入输出
    • 写入文件
    • 读取文件
    • 文件操作的实际应用
  • 随机数生成
    • 使用Random类
    • 随机数应用示例
  • 选择循环类型
    • 三种循环的比较
    • 选择建议
  • 习题