乐途乐途
主页
  • 计算机基础

    • TCP/IP
    • Linux
    • HTTP
  • 数据库

    • SQL
    • MySQL 5.7
  • 编程语言

    • C
    • C++
    • Java SE
    • Python2
    • Python3
  • 数据格式

    • JSON
    • XML
  • 认证与安全

    • JWT
  • 工具

    • Markdown
  • Git

    • GitFlow
  • Quartz

    • Quartz
  • Java

    • Maven 入门
    • Maven 进阶
    • MyBatis
    • Spring
    • Spring MVC
  • Java

    • Spring Boot
    • Spring Cloud
    • Spring Cloud Alibaba
    • Spring Security
    • Spring AI
    • Spring Batch
    • Kafka
    • Java 设计模式
  • 缓存

    • Redis
  • 搜索引擎

    • Elasticsearch
  • 分布式协调

    • ZooKeeper
联系
阿里云
主页
  • 计算机基础

    • TCP/IP
    • Linux
    • HTTP
  • 数据库

    • SQL
    • MySQL 5.7
  • 编程语言

    • C
    • C++
    • Java SE
    • Python2
    • Python3
  • 数据格式

    • JSON
    • XML
  • 认证与安全

    • JWT
  • 工具

    • Markdown
  • Git

    • GitFlow
  • Quartz

    • Quartz
  • Java

    • Maven 入门
    • Maven 进阶
    • MyBatis
    • Spring
    • Spring MVC
  • Java

    • Spring Boot
    • Spring Cloud
    • Spring Cloud Alibaba
    • Spring Security
    • Spring AI
    • Spring Batch
    • Kafka
    • Java 设计模式
  • 缓存

    • Redis
  • 搜索引擎

    • Elasticsearch
  • 分布式协调

    • ZooKeeper
联系
阿里云
  • 学习路径
  • 第1章 Java概述与环境搭建

    • Java概述与环境搭建
    • Java语言概述
    • 解释型语言与编译型语言对比
    • JDK安装与配置
    • JDK、JRE、JVM 详解
    • HelloWorld程序详解
    • IDE 介绍
  • 第2章 标识符与基本数据类型

    • 章节导读
    • 变量概述
    • 常量概述
    • 基本类型与包装类
    • 字节型 byte
    • 短整型 short
    • 整型 int
    • 长整型 long
    • 单精度浮点型 float
    • 双精度浮点型 double
    • 字符型 char
    • 布尔型 boolean
    • 类型转换
  • 第3章 运算符与表达式

    • 章节导读
    • 算术运算符
    • 赋值运算符
    • 关系运算符
    • 逻辑运算符
    • 位运算符
    • 条件运算符
    • 运算符优先级
    • 表达式
  • 第4章 流程控制

    • 章节导读
    • 常见的程序运行流程
    • if-else 选择结构
    • switch 多分支选择
    • while 循环
    • do-while 循环
    • for 循环
    • break 与 continue
  • 第5章 数组

    • 章节导读
    • 一维数组
    • 多维数组
    • Arrays 工具类
  • 第6章 类与对象

    • 章节导读
    • 类与对象
    • 方法定义与调用
    • 构造方法
    • 封装
    • 访问修饰符
    • package 与 import
    • static 关键字
    • this 关键字
    • 参数传递 详解
    • 枚举
    • 成员内部类
    • 局部内部类
    • 静态内部类
    • 匿名内部类
  • 第7章 接口与继承

    • 章节导读
    • 继承
    • super 关键字
    • final 关键字
    • 多态
    • 向上转型与向下转型
    • 抽象类
    • 接口
    • 抽象类与接口对比
  • 第8章 注解

    • 章节导读
    • 注解基础
    • 元注解详解
    • 自定义注解
  • 第9章 常用类

    • 章节导读:Java 常用类
    • Object 类:万类之祖
    • 包装类:基本类型的对象化
    • String:不可变的字符串
    • StringBuffer:线程安全的可变字符串
    • StringBuilder:可变的字符串构建器
    • Math:数学运算工具类
    • Random:伪随机数生成器
    • 大数值运算 详解
    • 日期时间API 详解
  • 第10章 异常机制

    • 章节导读
    • 异常体系与分类
    • try-catch-finally
    • try-with-resources
    • throws 与 throw
    • 自定义异常
  • 第11章 泛型

    • 章节导读
    • 泛型基础
    • 通配符与PECS原则
    • 类型擦除
  • 第12章 集合框架

    • 章节导读
    • 集合框架概述
    • ArrayList
    • LinkedList
    • HashMap 详解
    • LinkedHashMap 详解
    • TreeMap 详解
    • HashSet
    • TreeSet 详解
    • TreeSet 与 Comparable
    • Collections 工具类详解
  • 第13章 IO流

    • 章节导读
    • IO流概述
    • 字节流
    • 字符流
    • 缓冲流
    • 转换流 详解
    • 序列化 详解
    • NIO与Files 详解
    • NIO与Files工具类
  • 第14章 多线程与并发

    • 第十六章 多线程与并发 —— 章节导读
    • 线程基础详解
    • synchronized 详解
    • Lock 与显式锁详解
    • volatile 详解
    • wait 与 notify 详解
    • ThreadLocal详解
    • 原子类详解
    • 并发工具类详解
    • 线程池详解
  • 第15章 反射

    • 章节导读
    • 反射概述与 Class 对象
    • Constructor 与对象创建
    • Field与Method详解
    • 反射应用详解
  • 第16章 JDK8新特性

    • 章节导读
    • Lambda 表达式
    • Stream API 基础
    • Stream API 高级详解
    • Optional 详解
    • 新日期时间API详解
  • 第17章 JDK9-11新特性

    • 章节导读
    • 模块化系统 — Project Jigsaw(JDK 9)
    • var 局部变量类型推断(JDK 10)
    • 集合工厂方法与增强(JDK 9 / 10 / 11)
    • 接口增强:private 方法(JDK 9)
    • Stream API 增强(JDK 9)
    • Optional 增强(JDK 9 / 10 / 11)
    • String 新增方法(JDK 11)
    • HTTP Client 与 Files 增强(JDK 11)
    • 直接运行 Java 源文件 — JEP 330(JDK 11)
  • 第18章 JDK12-17新特性

    • 章节导读
    • Switch 表达式(JDK 12 预览 / JDK 14 正式)
    • 文本块 Text Blocks(JDK 13 预览 / JDK 15 正式)
    • Records 记录类(JDK 14 预览 / JDK 16 正式)
    • 密封类 Sealed Classes(JDK 15 预览 / JDK 17 正式)
    • instanceof 模式匹配(JDK 14 预览 / JDK 16 正式)
    • Switch 模式匹配 — Pattern Matching for switch(JDK 17 预览 / JDK 21 正式)
    • Helpful NPE 与 String 增强(JDK 12 / JDK 14 / JDK 15)
    • Stream 增强(JDK 12 / JDK 16)
    • 日期时间增强 — Day Period 支持(JDK 16)
  • 第19章 JDK18-21新特性

    • 章节导读
    • 虚拟线程(JDK 19 预览 / JDK 20 第二预览 / JDK 21 正式)
    • 序列集合(JDK 21 正式)
    • Switch 模式匹配(JDK 17 预览 / JDK 18 第二预览 / JDK 20 第四预览 / JDK 21 正式)
    • Record 模式匹配(JDK 19 预览 / JDK 20 第二预览 / JDK 21 正式)
    • 未命名模式与变量(JDK 21 预览 / JDK 22 正式)
  • 第20章 JDK 22-25 新特性

    • 章节导读
    • 字符串模板(JDK 22 预览 / JDK 23 第二预览 / JDK 24 第三预览)
    • Stream Gatherers(JDK 22 预览 / JDK 24 第二预览)
    • 隐式声明类与实例方法(JDK 23 预览 / JDK 24 第二预览)
    • 原始类型模式匹配(JDK 24 预览)
  • 附录

    • Java 核心知识点
    • Java SE 专业术语
    • Java特性索引(JDK 8 → 25)

do-while 循环

"菜单程序必须至少显示一次——用户还没看到菜单呢,你怎么能先问他'还要继续吗'?" —— Frank 在给飞翔云笔记设计命令行管理工具时,对实习生小崔解释了 do-while 的使用场景。


概述

do-while 循环是三种循环中唯一保证至少执行一次的循环结构。它先执行循环体,再判断条件——即使条件首次即为 false,循环体也已经执行了一轮。

三种循环执行次数对比

循环结构最少执行次数判断时机
for0 次先判断
while0 次先判断
do-while1 次后判断

语法格式

do {
    // 循环体(至少执行一次)
} while (布尔表达式);  // ← 注意这里的分号!

关键点表格

关键点说明
保证至少一次循环体在判断条件前就已执行
末尾分号while(条件); 末尾的分号不可省略
适合交互场景菜单、用户输入校验等"先做一次再决定是否继续"的场景
循环三要素初始化在 do 之前,条件在 while 括号内,迭代在循环体中

执行流程

与 while 的对比:while 是"判断→执行→判断→...",do-while 是"执行→判断→执行→..."。仅此顺序差异,带来了"至少一次"的保证。


示例一:命令行菜单交互

小崔为飞翔科技内部工具开发了一个命令行菜单,用户可以反复选择操作直到主动退出:

/**
 * 飞翔科技内部工具菜单——do-while 循环
 */
import java.util.Scanner;

public class CommandMenu {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int choice; // ① 初始化:在 do 之前声明

        System.out.println("===== 飞翔科技内部工具 v1.0 =====");

        do {
            // ② 循环体:显示菜单并获取用户选择
            System.out.println();
            System.out.println("请选择操作:");
            System.out.println("  1. 查看员工列表");
            System.out.println("  2. 添加工资记录");
            System.out.println("  3. 生成报表");
            System.out.println("  4. 系统设置");
            System.out.println("  0. 退出系统");
            System.out.print("请输入选项(0-4):");

            choice = scanner.nextInt(); // ③ 迭代:更新 choice
            scanner.nextLine(); // 消费换行符

            switch (choice) {
                case 1:
                    System.out.println(">> 正在加载员工列表...");
                    System.out.println(">> 大翔 | 白歌 | 小崔 | 朱璐 | Frank");
                    break;
                case 2:
                    System.out.println(">> 工资记录已添加。");
                    break;
                case 3:
                    System.out.println(">> 正在生成月度报表...");
                    System.out.println(">> 报表已发送至 admin@feixiang.net");
                    break;
                case 4:
                    System.out.println(">> 进入系统设置...");
                    break;
                case 0:
                    System.out.println(">> 正在退出系统,感谢使用!");
                    break;
                default:
                    System.out.println(">> 无效选项,请重新输入(0-4)。");
                    break;
            }

        } while (choice != 0); // ③ 条件:choice 不为 0 时继续循环

        scanner.close();
        System.out.println("系统已退出。");
    }
}
运行输出:
===== 飞翔科技内部工具 v1.0 =====

请选择操作:
  1. 查看员工列表
  2. 添加工资记录
  3. 生成报表
  4. 系统设置
  0. 退出系统
请输入选项(0-4):1
>> 正在加载员工列表...
>> 大翔 | 白歌 | 小崔 | 朱璐 | Frank

请选择操作:
  1. 查看员工列表
  2. 添加工资记录
  3. 生成报表
  4. 系统设置
  0. 退出系统
请输入选项(0-4):3
>> 正在生成月度报表...
>> 报表已发送至 admin@feixiang.net

请选择操作:
  1. 查看员工列表
  2. 添加工资记录
  3. 生成报表
  4. 系统设置
  0. 退出系统
请输入选项(0-4):0
>> 正在退出系统,感谢使用!
系统已退出。

示例二:输入数据校验

白歌为员工信息录入系统设计了输入校验——工号必须是 1000~9999 之间的整数,如果用户输入非法值则提示重新输入:

/**
 * 飞翔科技员工信息录入——do-while 输入校验
 */
import java.util.Scanner;

public class EmployeeInputValidation {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String name;
        int employeeId;

        System.out.println("===== 飞翔科技员工信息录入 =====");

        // do-while 确保至少提示一次输入
        do {
            System.out.print("请输入员工姓名(不能为空):");
            name = scanner.nextLine().trim();

            if (name.isEmpty()) {
                System.out.println("【错误】姓名不能为空,请重新输入。");
            }
        } while (name.isEmpty());

        // do-while 校验工号范围
        do {
            System.out.print("请输入工号(1000-9999):");
            employeeId = scanner.nextInt();
            scanner.nextLine(); // 消费换行符

            if (employeeId < 1000 || employeeId > 9999) {
                System.out.println("【错误】工号必须在 1000~9999 之间,"
                    + "你输入的是 " + employeeId);
            }
        } while (employeeId < 1000 || employeeId > 9999);

        System.out.println();
        System.out.println("--- 录入信息确认 ---");
        System.out.println("姓名:" + name);
        System.out.println("工号:" + employeeId);
        System.out.println("信息录入成功!");

        scanner.close();
    }
}
运行输出:
===== 飞翔科技员工信息录入 =====
请输入员工姓名(不能为空):
【错误】姓名不能为空,请重新输入。
请输入员工姓名(不能为空):小崔
请输入工号(1000-9999):99
【错误】工号必须在 1000~9999 之间,你输入的是 99
请输入工号(1000-9999):10000
【错误】工号必须在 1000~9999 之间,你输入的是 10000
请输入工号(1000-9999):1003

--- 录入信息确认 ---
姓名:小崔
工号:1003
信息录入成功!

do-while 与 while 的本质区别

用一个极简例子说明两者的差异:

// while:首先判断 i < 0,结果为 false,循环体一次都不执行
int i = 0;
while (i < 0) {
    System.out.println("while 循环体");  // 不会执行
}

// do-while:先执行循环体,然后判断 i < 0,结果为 false,退出
int j = 0;
do {
    System.out.println("do-while 循环体");  // 会执行一次!
} while (j < 0);
运行输出:
do-while 循环体

深度原理:do-while 循环的字节码实现

Java 源码:

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 3);

反编译字节码(javap -c):

 0: iconst_0              // i = 0
 1: istore_1
 2: getstatic  System.out    // ← 循环体起点:直接开始执行
 5: iload_1
 6: invokevirtual println    // println(i)
 9: iinc      1, 1           // i++
12: iload_1                  // 加载 i
13: iconst_3                 // 加载常量 3
14: if_icmplt  2             // 如果 i < 3,跳回偏移量 2(循环体起点)
17: return

与 while 字节码对比:

结构条件判断位置首次执行前是否有判断
while循环体之前有(if_icmpge 开头就判断)
do-while循环体之后无(直接进入循环体,最后才判断)

do-while 的字节码结构更紧凑——少了一次无条件 goto 跳转。但这点微小的性能差异在现代 JIT 编译器面前完全可以忽略。


易错场景

反例一:忘记末尾的分号

// ❌ 编译错误:do-while 末尾缺少分号
int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 3)   // 缺少分号!编译失败
// ✅ 正确:必须加分号
int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 3);  // ← 分号!

为什么需要分号? do { ... } while (条件); 是一个完整的语句,分号是语句结束的标志。与 while (条件) { ... } 不同,后者以 } 结尾,不需要额外分号。

反例二:误用 do-while 替代 while

// ❌ 错误:应该用 while,却用了 do-while
String[] names = {};
int i = 0;
do {
    System.out.println(names[i]);  // ArrayIndexOutOfBoundsException!
    i++;
} while (i < names.length);
// names 为空数组时,do 体仍然执行,导致数组越界
// ✅ 正确:空数组场景应该用 while(先判断)
String[] names = {};
int i = 0;
while (i < names.length) {
    System.out.println(names[i]);
    i++;
}
// 条件首次判断即为 false,循环体不执行,安全

反例三:while 条件中使用了未在 do 体内更新的变量

// ❌ 错误:条件中的变量在循环体内未更新 → 死循环
int count = 0;
int target = 5;
do {
    System.out.println("处理中...");
    // 忘记更新 count → 永远不会达到 target
} while (count < target);
// ✅ 正确:在循环体内更新条件变量
int count = 0;
int target = 5;
do {
    System.out.println("处理第 " + (count + 1) + " 次...");
    count++; // 必须更新!
} while (count < target);

反例四:循环变量作用域问题

// ❌ 错误:在 do 体内声明的变量,while 条件无法访问
do {
    int x = 10;
    // ...
} while (x > 0);  // 编译错误:cannot find symbol x
// ✅ 正确:在 do 之前声明变量
int x;
do {
    x = 10;
    // ...
} while (x > 0);

面试考点

Q1:do-while 和 while 的本质区别是什么?各适用于什么场景?

本质区别:判断时机不同——while 先判断后执行,do-while 先执行后判断。

适用场景:

  • do-while:需要确保循环体至少执行一次。如菜单交互(至少显示一次菜单)、输入校验(至少提示一次输入)、游戏主循环(至少渲染一帧)。
  • while:循环体可能不需要执行。如遍历集合(可能为空)、等待事件发生(事件可能已发生)、处理数据(可能没有数据)。

字节码层面:while 在循环体前有判断跳转指令;do-while 在循环体后才有判断,代码更紧凑。

Q2:为什么 do-while 在实际代码中使用频率远低于 for 和 while?

  1. "至少执行一次"的场景相对少:大多数循环场景(遍历、搜索、等待)都需要"可能不执行"的语义。
  2. 可读性:while 的条件放在开头,阅读代码时先看到退出条件;do-while 的条件在末尾,需要读完整个循环体才知道退出条件。
  3. for 更紧凑:已知次数的遍历几乎全用 for。

但这并不意味着 do-while 不重要——在正确的场景使用它,代码会更自然。

Q3:如何将 do-while 循环改写为 while 循环?代价是什么?

// do-while 版本
do {
    循环体
} while (条件);

// while 等价版本(需要重复循环体代码)
循环体;                     // 先执行一次
while (条件) {
    循环体;
}

代价:代码重复(DRY 原则违反)。如果循环体较长或需要修改,两个地方都要同步更新,容易出错。这就是 do-while 存在的价值——消除重复。

Q4:do-while(false) 有什么实际用途?

do { ... } while(false); 是一种代码块控制技巧,并非真正的循环:

do {
    if (condition1) break;
    if (condition2) break;
    // 正常执行逻辑
} while (false);

它模拟了"提前退出"的模式,类似于 goto 的安全替代。但在现代 Java 中,更好的方式是将逻辑抽取为独立方法并使用 return。


小结

要点说明
至少执行一次do-while 是唯一保证循环体至少执行一次的循环结构
末尾分号不可省while(条件); 的分号是语句结束标志
先执行,后判断循环体完成后才判断是否继续
适合交互场景菜单、输入校验、游戏主循环等需要先展示/响应的场景
字节码更紧凑相比 while 少一次无条件跳转(实际性能差异可忽略)
避免空集合越界遍历可能为空的集合时应使用 while 而非 do-while
上一页
while 循环
下一页
for 循环