【Java SE 基础学习打卡】24 循环结构 - while

目录

• 前言
• 一、先搞懂：循环的核心逻辑（为什么需要循环？）
• • [1.1 循环的 3 个核心要素（新手必记）](#1.1 循环的 3 个核心要素（新手必记）)
  • [1.2 while 和 do-while 的核心区别（先有印象）](#1.2 while 和 do-while 的核心区别（先有印象）)
• [二、逐个攻破：while 循环（先判断，后执行）](#二、逐个攻破：while 循环（先判断，后执行）)
• • [2.1 核心逻辑](#2.1 核心逻辑)
  • [2.2 语法模板（死记硬背）](#2.2 语法模板（死记硬背）)
  • [2.3 语法细节拆解](#2.3 语法细节拆解)
  • [2.4 生活场景：打印 1 到 5 的数字（基础示例）](#2.4 生活场景：打印 1 到 5 的数字（基础示例）)
  • [2.5 进阶场景：计算 1 到 10 的和（实用示例）](#2.5 进阶场景：计算 1 到 10 的和（实用示例）)
• [三、逐个攻破：do-while 循环（先执行，后判断）](#三、逐个攻破：do-while 循环（先执行，后判断）)
• • [3.1 核心逻辑](#3.1 核心逻辑)
  • [3.2 语法模板（死记硬背）](#3.2 语法模板（死记硬背）)
  • [3.3 语法细节拆解](#3.3 语法细节拆解)
  • [3.4 生活场景：累计做 50 个俯卧撑（基础示例）](#3.4 生活场景：累计做 50 个俯卧撑（基础示例）)
  • [3.5 进阶场景：统计一个数字的位数（实用示例）](#3.5 进阶场景：统计一个数字的位数（实用示例）)
• [四、while 和 do-while 的详细区别](#四、while 和 do-while 的详细区别)
• • [4.1 场景：判断 "钱包里有没有 20 元，有就买电影票"（钱包只有 10 元）](#4.1 场景：判断 “钱包里有没有 20 元，有就买电影票”（钱包只有 10 元）)
  • • [1. while 循环（先判断，后执行）](#1. while 循环（先判断，后执行）)
    • [2. do-while 循环（先执行，后判断）](#2. do-while 循环（先执行，后判断）)
  • [4.2 区别总结（3 个关键点）](#4.2 区别总结（3 个关键点）)
• [五、新手必避的 5 个 "致命坑"](#五、新手必避的 5 个 “致命坑”)
• • [5.1 坑 1：忘记更新值，导致死循环（最常见）](#5.1 坑 1：忘记更新值，导致死循环（最常见）)
  • [5.2 坑 2：do-while 末尾漏加分号](#5.2 坑 2：do-while 末尾漏加分号)
  • [5.3 坑 3：循环条件不是布尔表达式](#5.3 坑 3：循环条件不是布尔表达式)
  • [5.4 坑 4：循环体漏加大括号，导致更新值失控](#5.4 坑 4：循环体漏加大括号，导致更新值失控)
  • [5.5 坑 5：初始值设置错误，导致循环不执行或多执行](#5.5 坑 5：初始值设置错误，导致循环不执行或多执行)
• 总结

前言

上一节咱们学了 switch 语句，搞定了等值多分支判断。但编程中还有很多 "重复做事" 的场景：比如 "打印 1 到 10 的数字""每天打卡学习，连续 7 天""输入密码直到输对为止"------ 这些重复操作，总不能写 10 遍、7 遍重复代码吧？这时候就需要 "循环结构" 登场了。

while 循环是 Java 里最基础的循环工具，还有它的 "兄弟" do-while 循环，两者核心都是 "重复执行代码块"，区别只在 "先判断还是先执行"。这一节咱们就把这两种循环讲透：先学 while（先判断后执行），再学 do-while（先执行后判断），最后对比两者区别，全程用生活例子 + 超详细注释代码，保证刚学完分支结构的你也能轻松掌握！

一、先搞懂：循环的核心逻辑（为什么需要循环？）

循环的本质就是：让一段代码 "满足条件就重复执行"，直到条件不满足才停止。就像生活里 "每天早上 7 点起床，直到周末""刷题刷到及格为止"------ 核心是 "条件 + 重复"。

1.1 循环的 3 个核心要素（新手必记）

不管哪种循环，都离不开这 3 个要素，少一个就可能出问题：

1. 初始值：循环的 "起点"（比如打卡从第 1 天开始，打印数字从 1 开始）；

2. 循环条件：判断 "要不要继续循环"（比如打卡没到 7 天，数字没到 10）；

3. 更新值：让循环 "有机会结束"（比如打卡后天数 + 1，打印后数字 + 1）------ 少了这个就会陷入 "死循环"（永远停不下来）。

1.2 while 和 do-while 的核心区别（先有印象）

特点	while 循环	do-while 循环
执行顺序	先判断条件，再执行代码块	先执行代码块，再判断条件
首次条件不成立时	一次都不执行	至少执行一次
适用场景	不确定是否需要执行（比如找符合条件的数据）	确定至少执行一次（比如输入密码、菜单

二、逐个攻破：while 循环（先判断，后执行）

2.1 核心逻辑

就像 "先看钱包有没有钱，再决定买不买奶茶"：先判断条件（有钱≥15 元），条件成立就执行（买奶茶），不成立就不执行 ------ 全程可能一次都不买。

2.2 语法模板（死记硬背）

// 1. 初始值：循环的起点
初始化变量;

// 2. 循环条件：满足就继续，不满足就停止（必须是布尔表达式）
while (循环条件) {
    // 3. 循环体：要重复执行的代码（1行或多行）
    执行语句;
    
    // 4. 更新值：让变量变化，避免死循环（关键！）
    更新变量;
}

2.3 语法细节拆解

• 初始值：通常是整数变量（比如int i = 1;），也可以是其他类型（比如boolean isRunning = true;）；

• 循环条件：必须是布尔表达式（true/false），比如i <= 5、money >= 15，不能是数字或字符串；

• 循环体：用{ }包裹，哪怕只有一行代码也建议加 ------ 否则只有第一行代码受循环控制；

• 更新值：必须写在循环体里（或条件里），比如i++、money -= 15，让循环条件有机会变成false。

2.4 生活场景：打印 1 到 5 的数字（基础示例）

代码示例

public static void main(String[] args) {
    // 1. 初始值：从1开始（循环起点）
    int i = 1;

    // 2. 循环条件：i<=5（只要i不超过5，就继续循环）
    while (i <= 5) {
        // 3. 循环体：重复执行的代码（打印当前数字）
        System.out.println("当前数字：" + i);

        // 4. 更新值：i加1（让i逐渐接近5，避免死循环）
        i++; // 等价于i = i + 1
    }

    // 循环结束后执行的代码
    System.out.println("循环完成！");
}

执行结果：

当前数字：1
当前数字：2
当前数字：3
当前数字：4
当前数字：5
循环完成！

执行过程拆解（对应 3 个核心要素）

1. 初始：i=1，判断1<=5→true，执行循环体（打印 1），i变成 2；

2. 第二次：i=2，判断2<=5→true，打印 2，i变成 3；

3. 重复直到i=5：打印 5，i变成 6；

4. 第六次：i=6，判断6<=5→false，跳出循环，执行 "循环完成！"。

2.5 进阶场景：计算 1 到 10 的和（实用示例）

public static void main(String[] args) {
    int i = 1; // 初始值：从1开始
    int sum = 0; // 存储总和的变量（初始为0）

    while (i <= 10) { // 条件：i不超过10
        sum = sum + i; // 把当前i加到sum里（sum累加）
        i++; // 更新i：加1
    }

    System.out.println("1到10的和：" + sum); // 输出55
}

三、逐个攻破：do-while 循环（先执行，后判断）

3.1 核心逻辑

就像 "先试吃一口蛋糕，再决定买不买"：不管条件成立不成立，先执行一次（试吃），再判断条件（好吃就买）------ 全程至少执行一次。

3.2 语法模板（死记硬背）

// 1. 初始值：循环的起点
初始化变量;

do {
    // 2. 循环体：要重复执行的代码（至少执行一次）
    执行语句;
    
    // 3. 更新值：让循环有机会结束
    更新变量;
} while (循环条件); // 4. 循环条件：满足就继续，不满足就停止（注意末尾有分号！）

3.3 语法细节拆解

• 整体结构：do { 循环体 } while (条件);，末尾的;不能漏（否则编译报错）；

• 执行顺序：先执行do里的循环体，再判断while里的条件 ------ 哪怕条件一开始就不成立，循环体也会执行一次；

• 其他要素（初始值、更新值）和 while 循环一致，同样不能少更新值。

3.4 生活场景：累计做 50 个俯卧撑（基础示例）

代码示例

public static void main(String[] args) {
    // 1. 初始值：已做俯卧撑数量（从0开始）
    int done = 0;
    // 每次做的俯卧撑个数（固定10个/组）
    int perSet = 10;

    do {
        // 2. 循环体：先执行（至少做一组俯卧撑）
        done += perSet; // 累加俯卧撑数量（done = done + perSet）
        System.out.println("完成一组俯卧撑，累计完成：" + done + "个");

        // 3. 更新值：这里无需额外更新（done已通过累加更新）
        // 提示：如果累计没到50个，会重新执行循环体，再做一组
    } while (done < 50); // 4. 循环条件：累计<50个就继续做

    // 循环结束（累计够50个）
    System.out.println("恭喜！已完成50个俯卧撑目标～");
}

执行结果：

完成一组俯卧撑，累计完成：10个
完成一组俯卧撑，累计完成：20个
完成一组俯卧撑，累计完成：30个
完成一组俯卧撑，累计完成：40个
完成一组俯卧撑，累计完成：50个
恭喜！已完成50个俯卧撑目标～

执行过程拆解

1. 初始：done=0，进入do循环，执行循环体（done 变成 10，打印累计 10 个）；

2. 判断条件：10 < 50→true（没完成），继续循环；

3. 第二次：执行循环体（done 变成 20，打印累计 20 个），判断条件→true，继续循环；

4. 重复直到done=50：执行循环体（打印累计 50 个），判断条件→false（50 不小于 50），跳出循环，打印恭喜语。

3.5 进阶场景：统计一个数字的位数（实用示例）

比如统计 1234 的位数（结果是 4），不管数字是几，至少要统计一次，适合用 do-while：

public static void main(String[] args) {
    // 1. 初始值：要统计的数字（比如1234）
    int num = 1234;
    // 统计位数的变量（初始为0）
    int count = 0;
    // 临时变量：保存原始数字（避免修改num本身）
    int temp = num;

    do {
        // 2. 循环体：先执行（至少统计一次）
        temp = temp / 10; // 去掉数字的最后一位（1234→123→12→1→0）
        count++; // 位数加1

        // 3. 更新值：temp通过除法更新，逐渐变成0
    } while (temp != 0); // 4. 条件：temp不等于0就继续统计

    // 循环结束
    System.out.println("数字" + num + "的位数是：" + count); // 输出4
}

四、while 和 do-while 的详细区别

为了让你更直观感受到区别，我们用 "条件一开始就不成立" 的场景做对比：

4.1 场景：判断 "钱包里有没有 20 元，有就买电影票"（钱包只有 10 元）

1. while 循环（先判断，后执行）

public static void main(String[] args) {
    int money = 10; // 钱包有10元（不够20）

    while (money >= 20) { // 先判断：10>=20→false
        System.out.println("买电影票成功！"); // 一次都不执行
        money -= 20;
    }

    System.out.println("钱包钱不够，无法买票～");
}

执行结果：

钱包钱不够，无法买票～

2. do-while 循环（先执行，后判断）

public static void main(String[] args) {
    int money = 10;
    int ticketPrice = 20;

    do {
        System.out.println("尝试买电影票..."); // 先执行一次（哪怕钱不够）
        if (money >= ticketPrice) {
            System.out.println("买电影票成功！");
            money -= ticketPrice;
        } else {
            System.out.println("钱不够，本次未买到～");
        }
    } while (money >= ticketPrice); // 再判断：10>=20→false

    System.out.println("最终：钱包钱不够，无法买票～");
}

执行结果：

尝试买电影票...
钱不够，本次未买到～
最终：钱包钱不够，无法买票～

4.2 区别总结（3 个关键点）

1. 执行顺序：while 是 "判断→执行"，do-while 是 "执行→判断"；

2. 首次条件不成立：while 不执行循环体，do-while 执行一次；

3. 适用场景：while 用于 "不确定是否需要执行"（比如找数据），do-while 用于 "必须执行一次"（比如必须尝试一次操作后再判断）。

五、新手必避的 5 个 "致命坑"

5.1 坑 1：忘记更新值，导致死循环（最常见）

• 错误示例：

  int i = 1;
  while (i <= 5) {
      System.out.println(i);
      // 漏写更新值：i一直是1，条件永远成立
  }

• 后果：程序一直打印 1，停不下来（死循环），只能强制关闭；

• 正确示例：

  while (i <= 5) {
      System.out.println(i);
      i++; // 加上更新值，让i逐渐变大
  }

5.2 坑 2：do-while 末尾漏加分号

• 错误示例：

  int i = 1;
  do {
      System.out.println(i);
      i++;
  } while (i <= 5) // 漏写分号

• 后果：编译报错！提示 "需要 ';'"；

• 正确示例：

  } while (i <= 5); // 加上分号

5.3 坑 3：循环条件不是布尔表达式

• 错误示例：

  int i = 1;
  while (i) { // i是int类型，不是布尔表达式
      System.out.println(i);
      i++;
  }

• 后果：编译报错！提示 "不兼容的类型：int 无法转换为 boolean"；

• 正确示例：

  while (i <= 5) { // 布尔表达式（true/false）
      System.out.println(i);
      i++;
  }

5.4 坑 4：循环体漏加大括号，导致更新值失控

• 错误示例：

  int i = 1;
  while (i <= 5)
      System.out.println(i);
      i++; // 不受while控制，只执行一次（i变成2后，条件2<=5成立，但打印后i不再变）

• 后果：死循环！打印 1→i 变成 2→循环条件 2<=5 成立→打印 1（i 还是 2）→一直循环；

• 正确示例：

  while (i <= 5) {
      System.out.println(i);
      i++; // 受while控制，每次循环都执行
  }

5.5 坑 5：初始值设置错误，导致循环不执行或多执行

• 错误示例（while 循环）：

  int i = 6; // 初始值大于5，条件一开始就不成立
  while (i <= 5) {
      System.out.println(i); // 一次都不执行
      i++;
  }

• 后果：循环体不执行，达不到预期效果；

• 正确示例：

  int i = 1; // 初始值设置为循环起点
  while (i <= 5) {
      System.out.println(i);
      i++;
  }

总结

这一节咱们学了 while 和 do-while 两种循环，记住 3 个核心点：

1. 循环三要素：初始值、循环条件、更新值 ------ 少了更新值就会陷入死循环；

2. while 循环：先判断后执行，条件不成立则一次都不执行；

3. do-while 循环：先执行后判断，至少执行一次，适合必须做一次的场景（比如尝试操作、统计位数）。

循环是编程里 "自动化重复操作" 的核心，掌握这两种循环后，你可以实现很多实用功能（比如统计、倒计时、累计计算）。下一节咱们会学更灵活的for循环，处理固定次数的循环场景～