在之前的编程学习中,我们编写的程序都是按照顺序一条一条执行的,每个语句只执行一次。但是在实际编程中,我们经常需要让某些代码重复执行多次。 比如,我们需要打印100次“Hello World”,或者需要计算1到100的和,或者需要读取用户输入的多个数据。
这种让代码重复执行的结构在编程中称为循环。循环是编程中最基本也是最重要的概念之一,它让计算机能够不知疲倦地重复执行相同的任务。

在正式学习循环结构之前,我们需要先掌握递增(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循环是Java中最基本、最常用的循环结构之一。它的核心思想是:在每次循环开始前,先判断一个条件表达式是否为真。
如果条件为真(即条件表达式的结果为true),就会执行循环体内的代码块;执行完毕后,再次判断条件是否为真,如此反复,
直到条件为假(即条件表达式的结果为false)时,循环才会终止,程序会继续执行循环后面的代码。
也就是说,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循环是如何工作的:
number的初始值为1number <= 5是否为真number++,将number的值增加1在上面的例子中,number变量被称为循环控制变量,它控制着循环的执行次数。循环控制变量通常需要:
如果循环条件永远不会变为假,循环就会无限执行下去,这称为无限循环。例如:
|int number = 1; while (number <= 5) { System.out.println("数字: " + number); // 忘记更新number,导致无限循环 }
这个循环会无限打印"数字: 1",因为number的值永远不会改变。
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循环是while循环的一种变体。与while循环不同,do-while循环无论条件是否成立,都会先执行一次循环体,然后再判断条件是否满足,决定是否继续执行后续循环。也就是说,do-while循环至少会执行一次循环体。其执行流程如下:
这种结构特别适合需要“至少执行一次”的场景,比如菜单选择、用户输入验证等。相比之下,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(

for循环是Java中最常用、最基础的循环结构之一。它非常适合用于需要重复执行固定次数操作的场景,比如遍历数组、统计数据、批量处理等。
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循环有多种使用方式:
|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
我们也可以让用户决定循环的次数:
|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("请输入每门课程的数量: ");
在前面的switch语句中,我们已经见过break语句的用法。在循环结构中,break语句同样非常重要。它的作用是立即终止当前所在的循环,无论循环条件是否还为真,遇到break后都会直接跳出循环体,
程序会从循环后面的第一条语句继续执行。
通常,break语句用于以下几种场景:
需要注意的是,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后面的代码,开始下一轮循环(如果循环条件仍然成立)。
常见用法包括:在满足某些条件时,不执行本次循环的后续操作,而是直接进行下一次循环。例如,过滤掉不需要处理的数据、跳过某些特殊情况等。
举例说明:在一个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();
在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
|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 <=
输出结果:
|1 2 3 4 5 6 7 8 9 10
说明:
i为1i <= 10控制循环次数i++递增循环变量i变为11时,条件为假,循环结束输出结果:
|1到100的和是: 5050
说明:
sum变量累计和,初始化为0for循环从1到100遍历i加到sum中输出结果:
|* ** *** **** *****
说明:
println()换行说明:
do-while循环确保至少执行一次输入说明:
sum变量累计所有输入的数字for循环执行5次,每次读取一个数字sum中