思维导图：
2.5.1 while循环结构
**2.5 循环结构语句**
**引言**:
在日常生活中，我们常常会重复某些行为，如做眼保健操时重复某个动作或打乒乓球时重复挥拍。在Java编程中，这种重复性的行为可以通过循环语句来实现。
**循环语句的种类**:
1. `while` 循环
2. `do...while` 循环
3. `for` 循环
---
**2.5.1 `while` 循环**
与2.4节的选择结构语句相似，`while` 循环也是基于一个条件来执行的。但不同之处在于，只要条件成立，`while` 循环内的代码块就会一直重复执行，直到条件不再成立。
**语法**:
```java
while(循环条件) {
// 循环体代码
}
```
**示例**:
```java
int x = 1;
while(x <= 4) {
System.out.println("x=" + x);
x++;
}
```
该代码的作用是打印从1到4的数字。注意到`x++`这一操作非常关键，它使x的值逐渐增加，否则循环将会无止境地进行下去，因为`x`值将始终为1，满足`x <= 4`的条件。
---
**2.5.2 `do...while` 循环**
这种循环结构首先执行一次循环体，然后检查循环条件。只要条件为真，循环体就会继续执行。
**语法**:
```java
do {
// 循环体代码
} while(循环条件);
```
**特点**:
与`while`循环相比，`do...while`循环至少会执行一次，无论循环条件在开始时是否成立。
---
**重点**:
1. 为避免无限循环，确保在循环体内部有改变循环条件的语句。
2. 根据实际需求选择合适的循环结构。如果至少需要执行一次循环体，考虑使用`do...while`循环；否则使用`while`或`for`循环。
**易错点**:
1. 忘记在循环体内部更新循环变量，导致无限循环。
2. 混淆`while`循环和`do...while`循环的语法和使用场景。
**使用技巧**:
1. 在编写循环前，先确定循环的终止条件。
2. 如果循环体需要至少执行一次，使用`do...while`循环。
3. 对于有明确的起始和结束条件的循环，考虑使用`for`循环。
2.5.2 do...while循环语句
**2.5.2 `do...while` 循环语句**
**基本概念**:
`do...while` 循环与 `while` 循环功能相似，但主要的区别在于执行顺序。在 `do...while` 循环中，循环体会首先执行一次，然后再检查循环条件。
**语法**:
```java
do {
// 循环体
} while(循环条件);
```
**特点**:
1. 循环体至少执行一次，即使循环条件最开始就不满足。
2. 循环条件在循环体后面进行判断。
**示例**:
```java
public class Example13 {
public static void main(String[] args) {
int x = 1;
do {
System.out.println("x=" + x);
x++;
} while(x <= 4);
}
}
```
运行这段代码，输出结果是从1到4的数字。与 `while` 循环的结果相同。
**对比**:
假设我们将循环条件改为 `x < 1`：
- 在 `while` 循环中，循环体一次都不会执行，因为循环条件从一开始就不满足。
- 但在 `do...while` 循环中，循环体仍会执行一次，然后才判断循环条件，发现不满足条件并退出循环。
**总结**:
- `do...while` 循环最大的特点是循环体至少执行一次。
- 而 `while` 循环可能一次都不执行，这取决于循环条件的初始状态。
**应用建议**:
选择使用 `do...while` 还是 `while` 循环，主要取决于具体需求。如果需要确保循环体至少执行一次，无论循环条件是否满足，那么选择 `do...while`。反之，如果循环体的执行完全取决于条件，那么选择 `while` 循环。
2.5.3 for循环语句
**2.5.3 `for` 循环语句**
**基本概念**:
`for` 循环主要用于已知循环次数的情况。其结构包括初始化表达式、循环条件和操作表达式。
**语法**:
```java
for(初始化表达式; 循环条件; 操作表达式) {
// 执行语句 (循环体)
}
```
**执行流程**:
1. 执行初始化表达式。
2. 检查循环条件。如果为 `true`，继续执行，否则跳出循环。
3. 执行循环体。
4. 执行操作表达式，然后返回第二步。
**示例**:
public class Example14 {
public static void main(String[] args) {
int sum = 0;
for(int i = 1; i <= 4; i++) {
sum += i;
}
System.out.println("sum=" + sum);
}
}
在上面的例子中，`i` 的初始值为1，每次循环增加1，直到 `i` 的值为5（此时不满足循环条件 i<=4），循环结束。
**特点**:
- `for` 循环为程序员提供了一种简洁的方式来执行已知次数的循环。
- `for` 循环中的三个部分（初始化、条件、操作）都位于同一个地方，使得逻辑更为集中。
**循环比较**:
- `while` 和 `do...while` 循环更适用于循环次数不确定的情况；而 `for` 循环更适用于已知循环次数的情况。
- `while` 和 `for` 循环先判断循环条件，再执行循环体；而 `do...while` 循环则是先执行循环体，再判断循环条件。
**小实验**:
public class Test {
public static void main(String[] args) {
// while循环
int num = 0;
while(num <= 10) {
if(num % 2 != 0) {
System.out.print(num + ",");
}
num++;
}
System.out.println();
// do…while循环
int num2 = 0;
do {
if(num2 % 2 != 0) {
System.out.print(num2 + ",");
}
num2++;
} while(num2 <= 10);
System.out.println();
// for循环
for(int i = 1; i <= 10; i++) {
if(i % 2 != 0) {
System.out.print(i + ",");
}
}
System.out.println();
}
}
上面的代码示例显示了 `while`、`do...while` 和 `for` 循环如何输出10以内的所有奇数。所有的循环都能达到相同的效果，但每种循环在语法和结构上都有所不同。
**总结**:
- 选择哪种循环主要取决于具体的应用场景和程序员的偏好。
- 了解每种循环的特点和适用场景可以帮助程序员编写更加高效和清晰的代码。
2.5.4 循环嵌套
# 2.5.4 循环嵌套
循环嵌套是指在一个循环语句的循环体中再定义一个循环语句。`while`、`do...while`、和`for`循环语句都可以嵌套，并且它们之间可以互相嵌套。常见的例子是在一个`for`循环中嵌套另一个`for`循环。
## 循环类型的选择
- `while` 和 `do...while` 循环适用于循环次数不确定的场景。
- `for` 循环适用于循环次数确定的场景。
## 循环执行顺序
- `while` 和 `for` 先判断循环条件，再执行循环体。
- `do...while` 先执行循环体，再判断循环条件。
## 示例：输出10以内的所有奇数
使用三种循环方法：
// 使用while循环
int num = 0;
while(num <= 10) {
if(num % 2 != 0) {
System.out.println(num + ",");
}
num++;
}
// 使用do...while循环
int num2 = 0;
do {
if(num2 % 2 != 0) {
System.out.println(num2 + ",");
}
num2++;
} while(num2 <= 10);
// 使用for循环
for(int i = 1; i <= 10; i++) {
if(i % 2 != 0) {
System.out.println(i + ",");
}
}
## 使用循环嵌套打印直角三角形
public class Example15 {
public static void main(String[] args) {
for(int i = 1; i <= 9; i++) { //外层循环
for(int j = 1; j <= i; j++) { //内层循环
System.out.print("*");
}
System.out.println(); //换行
}
}
}
在上面的代码中，定义了两层for循环，外层循环用于控制打印的行数，而内层循环用于控制每行打印的列数。因此，每行的`*`数量逐行递增，从而形成一个直角三角形。
## 嵌套循环的执行过程
1. 定义两个循环变量i和j。
2. 初始化i为1，判断i<=9，首次进入外层循环体。
3. 初始化j为1，判断j<=i，首次进入内层循环体，打印一个*。
4. 自增j的值。
5. 继续判断j的循环条件，直到条件不满足，结束内层循环。
6. 执行外层循环的操作，i自增。
7. 继续判断i的循环条件，直到条件不满足，结束外层循环。
这样，通过嵌套循环，可以简洁地实现复杂的循环逻辑。
2.5.5 跳转语句
# 2.5.5 跳转语句
跳转语句用于控制程序执行流程的跳转。在 Java 中，常见的跳转语句包括 `break` 和 `continue`。
## 1. `break` 语句
### 功能和使用场合:
- **在 `switch` 语句中**: `break` 用于终止某个 `case` 并跳出 `switch` 结构。
- **在循环语句中**: `break` 用于立即终止循环并跳出循环结构，执行循环后面的代码。
### 示例:
public class Example16 {
public static void main(String[] args) {
int x = 1; // 定义变量x, 初始值为1
while(x <= 4) {
System.out.println("x=" + x); // 条件成立，打印x的值
if(x == 3) {
break; // 当x为3时，跳出循环
}
x++; // x自增
}
}
}
在上述代码中，当 `x` 的值为3时，`break` 语句执行，跳出 `while` 循环。因此，输出结果是 `x=1`，`x=2` 和 `x=3`，并不会有 `x=4`。
## 2. `continue` 语句
### 功能:
- `continue` 语句用于结束当前循环迭代，并立即开始下一次迭代。它仅影响包含它的最内层循环。
### 示例:
假设我们想在 1 到 10 之间打印所有非3的倍数。
for(int i = 1; i <= 10; i++) {
if(i % 3 == 0) {
continue; // 跳过3的倍数
}
System.out.println(i);
}
这个循环会跳过所有3的倍数，并打印其他数字。
**总结**: `break` 和 `continue` 是 Java 中用于控制循环执行流程的强大工具。正确和高效地使用它们可以使程序更简洁和易于理解。
总结：
**Java中的循环结构语句总结：**
### 重点：
1. **基本循环结构**：Java支持三种主要的循环结构：`for`、`while` 和 `do...while`。
2. **嵌套循环**：在一个循环内部可以再嵌套其他循环，常见的是for循环中嵌套for循环，用于处理多维数据结构，如数组和矩阵。
3. **跳转语句**：`break` 和 `continue`。`break` 用于立即退出循环或switch语句；`continue` 用于跳过循环的当前迭代，并开始下一个迭代。
### 难点：
1. **循环逻辑理解**：特别是对于新手，理解循环的执行逻辑、判断条件和迭代操作可能会有所困难。
2. **嵌套循环的复杂度**：多层嵌套会使代码变得难以阅读和维护，也容易引入错误。
3. **无限循环**：如果不正确地设置循环条件或忘记更新迭代变量，可能会导致无限循环。
### 易错点：
1. **边界条件错误**：例如，使用 `<` 而不是 `<=`，或者相反。
2. **忘记更新迭代变量**：在循环体内没有正确地更新迭代变量，导致无限循环。
3. **误用 `break` 和 `continue`**：例如，在尝试跳出多层嵌套循环时，只使用一个 `break`，导致只退出了内层循环。
4. **循环变量的作用域**：在for循环外部错误地使用了循环控制变量。
### 使用技巧：
1. **简洁明了**：保持循环逻辑尽量简单和清晰，避免使用太多的嵌套结构。
2. **适时的注释**：为复杂的循环逻辑添加注释，解释循环的目的和关键步骤。
3. **检查边界条件**：在编写循环时，始终检查和测试边界条件，确保循环的开始和结束都是预期的。
4. **使用增强的for循环**：当遍历数组或集合时，考虑使用Java的增强for循环（也称为“for-each”循环）。
5. **防止无限循环**：在编写循环时，始终确保有一个明确的退出条件，并定期检查该条件。
6. **嵌套循环优化**：当面对多层嵌套循环时，考虑是否可以通过重构或其他方法简化循环结构。
7. **利用调试器**：使用IDE的调试功能逐步执行循环，查看变量的变化，帮助理解和排查问题。
扫一扫
5940
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
