当谈到循环结构时，Java提供了多种循环结构，可以重复执行特定的代码块。其中包含了下面不同类型的循环结构。
1.1 基本语法
在Java中，for循环的基本语法如下：
for (初始化表达式; 循环条件; 更新表达式) {
// 循环体
}
- 初始化表达式：在循环开始之前执行的语句，通常用于初始化循环变量。
- 循环条件：在每次循环开始之前进行判断的条件，只有当条件为真时，循环才会执行。
- 更新表达式：在每次循环结束之后执行的语句，通常用于更新循环变量的值。
1.2 示例：计算1到10的和
下面是一个使用for循环计算从1到10的和的示例：
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum += i;
}
System.out.println("1到10的和为：" + sum);
运行上述代码，将输出以下结果：
1到10的和为：55
在这个示例中，我们使用for循环将变量 i 从1递增到10，并将每个值加到变量 sum 上。最后，我们打印出 sum 的值，即1到10的和。
1.3 示例：遍历数组
for循环也常用于遍历数组。下面是一个使用for循环遍历数组并打印数组元素的示例：
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
运行上述代码，将输出以下结果：
1
2
3
4
5
在这个示例中，我们定义了一个整型数组 numbers，然后使用for循环遍历数组的每个元素并打印出来。循环变量 i 从0递增到 numbers.length - 1，并使用 numbers[i] 访问每个数组元素。
2.1 基本语法
在Java中，while循环的基本语法如下：
while (循环条件) {
// 循环体
// 更新循环条件
}
- 循环条件：在每次循环开始之前进行判断的条件，只有当条件为真时，循环才会执行。
- 循环体：包含在循环中需要重复执行的代码。
- 更新循环条件：在循环体中更新循环条件的值，以确保循环能够终止。
2.2 示例：计算1到10的和
下面是一个使用while循环计算从1到10的和的示例：
int sum = 0;
int i = 1;
while (i <= 10) {
sum += i;
i++;
}
System.out.println("1到10的和为：" + sum);
运行上述代码，将输出以下结果：
1到10的和为：55
在这个示例中，我们使用while循环将变量 i 从1递增到10，并将每个值加到变量 sum 上。在每次循环结束之后，我们使用 i++ 更新循环条件，确保循环能够终止。
2.3 示例：读取用户输入
while循环也常用于读取用户的输入，直到满足特定条件。下面是一个使用while循环读取用户输入的示例：
import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
String input;
while (true) {
System.out.print("请输入一个数字：");
input = scanner.nextLine();
if (input.equals("quit")) {
break;
}
int number = Integer.parseInt(input);
System.out.println("您输入的数字是：" + number);
}
System.out.println("程序结束");
在这个示例中，我们使用while循环读取用户的输入，直到用户输入了字符串 "quit" 才结束循环。在每次循环中，我们打印提示信息并使用 scanner.nextLine() 获取用户的输入。然后，我们使用 Integer.parseInt() 将输入转换为整数，并打印出来。如果用户输入了 "quit"，我们使用 break 语句退出循环。
3.1 基本语法
在Java中，do-while循环的基本语法如下：
do {
// 循环体
// 更新循环条件
} while (循环条件);
- 循环体：包含在循环中需要重复执行的代码。
- 更新循环条件：在循环体中更新循环条件的值，以决定是否继续执行循环。
- 循环条件：在每次循环结束之后进行判断的条件，只有当条件为真时，循环会继续执行。
请注意，do-while循环保证循环体至少执行一次，因为循环条件是在循环结束后进行判断。
3.2 示例：猜数字游戏
下面是一个使用do-while循环实现猜数字游戏的示例：
import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
int secretNumber = 42;
int guess;
do {
System.out.print("猜一个数字：");
guess = scanner.nextInt();
if (guess < secretNumber) {
System.out.println("太小了，请再猜一次！");
} else if (guess > secretNumber) {
System.out.println("太大了，请再猜一次！");
} else {
System.out.println("恭喜，猜对了！");
}
} while (guess != secretNumber);
System.out.println("游戏结束");
在这个示例中，程序生成了一个秘密数字 secretNumber，然后使用do-while循环来实现猜数字的游戏。在每次循环中，程序提示用户猜一个数字，并将用户的猜测与秘密数字进行比较。根据猜测的大小，程序给出相应的提示，直到用户猜对为止。
3.3 示例：循环菜单
do-while循环也可以用于实现循环菜单的功能。下面是一个使用do-while循环实现简单循环菜单的示例：
import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
int choice;
do {
System.out.println("请选择操作：");
System.out.println("1. 添加新记录");
System.out.println("2. 查看记录");
System.out.println("3. 删除记录");
System.out.println("0. 退出");
choice = scanner.nextInt();
switch (choice) {
case 1:
System.out.println("执行添加新记录操作");
break;
case 2:
System.out.println("执行查看记录操作");
break;
case 3:
System.out.println("执行删除记录操作");
break;
case 0:
System.out.println("退出程序");
break;
default:
System.out.println("无效的选择，请重新选择");
break;
}
} while (choice != 0);
System.out.println("程序结束");
在这个示例中，程序通过do-while循环实现了一个简单的循环菜单。在每次循环中，程序打印菜单选项，并根据用户的选择执行相应的操作。当用户选择退出时，循环结束，程序退出。
4.1 基本语法
在Java中，嵌套循环是指在一个循环体内包含另一个循环。嵌套循环的基本语法如下：
for (初始化表达式1; 循环条件1; 更新表达式1) {
// 外层循环体
for (初始化表达式2; 循环条件2; 更新表达式2) {
// 内层循环体
}
}
在嵌套循环中，外层循环体包含了内层循环体。内层循环的执行次数由外层循环的执行次数决定。可以在内层循环中访问外层循环的变量。
4.2 示例：九九乘法表
下面是一个使用嵌套循环打印九九乘法表的示例：
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
int result = i * j;
System.out.print(i + " * " + j + " = " + result + " ");
}
System.out.println();
}
运行上述代码，将输出以下结果：
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
在这个示例中，我们使用两个嵌套的for循环，外层循环控制乘法表的行数，内层循环控制每行的列数。在内层循环中，我们计算乘法的结果并打印出来。
4.3 示例：打印图形
下面是一个使用嵌套循环打印图形的示例，以打印一个直角三角形为例：
int rows = 5;
for (int i = 1; i <= rows; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("* ");
}
System.out.println();
}
运行上述代码，将输出以下结果：
*
* *
* * *
* * * *
* * * * *
在这个示例中，我们使用两个嵌套的for循环，外层循环控制行数，内层循环控制每行的打印数量。在这个示例中，我们使用两个嵌套的for循环，外层循环控制行数，内层循环控制每行的打印数量。在内层循环中，我们打印一个星号 "*" 来构成图形。
这就是使用Java的嵌套循环的基本语法以及一些示例。你也可以根据需要进行修改和扩展，以实现更复杂的循环逻辑和打印图形。
5.1 break语句
在Java中，break语句用于提前结束循环，即使循环条件仍然为真。break语句的使用示例如下：
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break;
}
System.out.println(i);
}
上述代码中，当i等于5时，break语句被执行，循环提前结束。输出结果如下：
1
2
3
4
break语句还可以在嵌套循环中使用，用于提前结束外层循环。例如：
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
if (i * j > 10) {
break;
}
System.out.println(i * j);
}
}
上述代码中，当乘积超过10时，break语句被执行，内层循环提前结束，但外层循环继续执行。输出结果如下：
1
2
3
4
5
2
4
6
5.2 continue语句
在Java中，continue语句用于跳过当前循环迭代，直接进入下一次循环迭代。continue语句的使用示例如下：
for (int i = 1; i <= 5; i++) {
if (i == 3) {
continue;
}
System.out.println(i);
}
上述代码中，当i等于3时，continue语句被执行，当前迭代被跳过，直接进入下一次迭代。输出结果如下：
1
2
4
5
continue语句同样可以在嵌套循环中使用，用于跳过当前迭代并进入下一次迭代。例如：
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
if (i == j) {
continue;
}
System.out.println(i + " " + j);
}
}
上述代码中，当i等于j时，continue语句被执行，内层循环的当前迭代被跳过，直接进入下一次迭代。输出结果如下：
1 2
1 3
1 4
1 5
2 1
2 3
2 4
2 5
3 1
3 2
3 4
3 5
4 1
4 2
4 3
4 5
5 1
5 2
5 3
5 4
5.3 示例：找到特定数字
下面是一个使用break语句在循环中找到特定数字并结束循环的示例：
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
if (number == 3) {
System.out.println("找到了特定数字：" + number);
break;
}
}
System.out.println("循环结束");
运行上述代码，将输出以下结果：
找到了特定数字：3
循环结束
在这个示例中，我们使用for-each循环遍历数组numbers，当找到特定数字3时，使用break语句结束循环。在循环结束后，打印出"循环结束"的消息。
这就是使用Java的循环控制语句break和continue的基本语法以及一些示例。
6.1 基本语法
增强for循环用于遍历数组或集合中的元素，它提供了一种简洁的方式来迭代访问元素，而不需要使用传统的循环索引。增强for循环的基本语法如下：
for (元素类型 变量名 : 遍历对象) {
// 循环体
}
在增强for循环中，变量会依次取遍历对象中的每个元素。在循环体内，您可以对每个元素执行所需的操作。增强for循环适用于数组、实现了Iterable接口的集合类以及其他可迭代的对象。
6.2 示例：遍历集合
下面是一个使用增强for循环遍历集合的示例：
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
for (String fruit : fruits) {
System.out.println(fruit);
}
}
}
运行上述代码，将输出以下结果：
Apple
Banana
Orange
在这个示例中，我们创建了一个List类型的集合fruits，并添加了几个水果。然后，我们使用增强for循环遍历集合中的每个元素，并打印出来。
需要注意的是，在增强for循环中，变量fruit会依次取fruits集合中的每个元素，这里的元素类型是String。您可以根据需要修改变量类型和集合对象进行遍历。
这就是使用Java的增强for循环的基本语法以及一个示例。增强for循环提供了一种简洁的方式来遍历数组和集合中的元素，使代码更加清晰和易读。
