Java基础快速入门: for、while、do-while、跳转与死循环

本文纲要

1. 循环的概念
2. for循环
   格式与执行流程
   案例1：输出1-5和5-1
   案例2：求1-5数据和
   案例3：求1-100偶数和
   案例4：水仙花数
   案例5：每行打印两个水仙花数（统计思想）
3. while循环
   格式与执行流程
   案例：珠穆朗玛峰折纸问题
4. do-while循环
   格式与特点
5. 三种循环的区别
6. 死循环
7. 跳转控制语句
   continue 跳过本次循环
   break 终止整个循环
8. 循环标号（标签）
9. 总结

循环的概念

循环指重复执行某段代码，具有明确的开始和结束标志（如抄课文100遍，抄完即结束）

若循环没有出口，则称为死循环（如“不开心就吃，吃了就胖，胖了就不开心”的无限闭环）

Java中提供for、while、do-while三种循环结构，可分别处理不同场景

for循环

1 ) 格式与执行流程

格式：

for (初始化语句; 条件判断语句; 条件控制语句) {
    循环体语句;
}

初始化语句：定义变量，用于控制循环次数（仅执行一次）
条件判断语句：返回布尔值，决定是否继续循环
条件控制语句：每次循环结束后修改变量（如自增、自减）
循环体语句：要重复执行的任务

执行流程：

2 ) 案例1：输出1-5和5-1

需求：在控制台分别输出1到5和5到1

分析：
1到5：初始化变量i=1，条件i<=5，每次i++，循环体内打印i
5到1：初始化i=5，条件i>=1，每次i–

代码：

public class Demo2For {
    public static void main(String[] args) {
        // 1-5 
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        System.out.println("--------------");
        // 5-1 
        for (int i = 5; i >= 1; i--) {
            System.out.println(i);
        }
    }
}

要点：
循环变量i不仅控制循环次数，还可作为逻辑数据在循环体内使用
条件控制语句不限于i++，也可使用i–等

3 ) 案例2：求1-5数据和

需求：计算1到5的和并输出

分析：
求和需定义变量sum，初始值0
循环中让sum累加变量i（i代表1到5每个数）

代码：

public class Demo3For {
    public static void main(String[] args) {
        int sum = 0;                     // 求和变量 
        for (int i = 1; i <= 5; i++) {
            sum += i;                    // sum = sum + i 
        }
        System.out.println("1-5的和为：" + sum); // 15 
    }
}

规律：今后需求中若出现“求和”字样，就应定义int sum = 0;作为累加器

4 ) 案例3：求1-100偶数和
需求：求1到100之间所有偶数的和

分析：
循环获取1~100每个数，用if(i % 2 == 0)判断偶数，是偶数则累加到sum

代码：

public class Demo4For {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        System.out.println("1-100之间的偶数和为：" + sum); // 2550 
    }
}

若求奇数和，只需将条件改为i % 2 != 0即可

5 ) 案例4：水仙花数

需求：输出所有三位水仙花数（个位、十位、百位的立方和等于原数）

分析：

1. 循环100~999获取所有三位数
2. 拆分出个位、十位、百位：
   个位：i % 10
   十位：i / 10 % 10
   百位：i / 100
3. 判断立方和是否等于i，成立则打印

代码：

public class Demo5For {
    public static void main(String[] args) {
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;
            if (gegege + shishishi + baibaibai == i) {
                System.out.println(i);
            }
        }
    }
}

6 ) 案例5：每行打印两个水仙花数（统计思想）

需求：输出所有水仙花数，每行显示两个，用空格分隔

分析：

• 定义计数器count初始为0
• 每打印一个水仙花数后count++
• 每次自增后检查count是否为2的倍数，若是则换行
• 打印时使用System.out.print(i + " ") 避免换行

代码：

public class Demo6For {
    public static void main(String[] args) {
        int count = 0;                     // 统计已打印个数 
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;
            if (gegege + shishishi + baibaibai == i) {
                System.out.print(i + " "); // 不换行 
                count++;
                if (count % 2 == 0) {      // 每两个数后换行 
                    System.out.println();  // 空换行 
                }
            }
        }
    }
}

要点：统计数量时，定义计数器变量，在特定条件触发时自增，并通过判断是否为倍数来实现格式化输出，这是一种通用的统计思想。

while循环

1 ) 格式与执行流程

格式：

初始化语句;
while (条件判断语句) {
    循环体语句;
    条件控制语句;
}

执行流程与for循环类似，但各个部分的位置不同：

改写练习：将for循环改写为while循环

for版本：

for (int i = 1; i <= 100; i++) {
    System.out.println(i);
}

while版本（注意变量提升）：

int i = 1;
while (i <= 100) {
    System.out.println(i);
    i++;
}

注意：while的小括号后不能加分号，否则会变成空循环体，导致死循环。

2 ) 案例：珠穆朗玛峰折纸问题

需求：珠峰高度8844430毫米，纸张厚度0.1毫米，问折叠多少次能超过珠峰高度？

分析：
折叠次数未知 → 使用while循环（不明确循环次数时推荐while）。
循环条件：纸张厚度小于等于珠峰高度时继续折叠。
每次折叠厚度翻倍：paper *= 2。
计数器count记录折叠次数。

代码：

public class Demo2While {
    public static void main(String[] args) {
        double paper = 0.1;               // 纸张初始厚度（毫米）
        int zf = 8844430;                 // 珠峰高度（毫米）
        int count = 0;                    // 折叠次数计数器 
        while (paper <= zf) {
            paper *= 2;                   // 对折一次厚度翻倍 
            count++;
        }
        System.out.println("需要折叠：" + count + "次"); // 27 
    }
}

do-while循环

1 ) 格式与特点

格式：

初始化语句;
do {
    循环体语句;
    条件控制语句;
} while (条件判断语句);

特点：无论条件是否成立，循环体至少执行一次。因为执行语句、条件控制语句之后才进行条件判断。

2 ) 示例：

public class Demo1DoWhile {
    public static void main(String[] args) {
        int i = 11;                      // 初始值不满足条件 
        do {
            System.out.println("黑马程序员");
            i++;
        } while (i <= 10);               // 条件为false，但循环体仍执行一次 
        System.out.println(i);           // 输出12 
    }
}

多数开发场景中do-while不常用，但理解其特性有助于阅读他人代码

三种循环的区别

区别点	for	while	do-while
初始化变量作用域	循环内部定义的变量在循环结束后消失	变量定义在循环外，循环结束后仍可访问	同 while
执行顺序	先判断，后执行	先判断，后执行	先执行一次，再判断
应用场景	明确循环次数	循环次数不确定	需至少执行一次的场景（极少）

变量作用域演示：

public class Loop {
    public static void main(String[] args) {
        // for循环中的变量i，循环结束后无法访问 
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        // System.out.println(i); // 编译错误，找不到符号i 
 
        // while循环的变量a在循环外定义，循环结束后仍可用 
        int a = 1;
        while (a <= 5) {
            System.out.println(a);
            a++;
        }
        System.out.println(a + "...");   // 输出6...
    }
}

因此，若for循环结束后还需使用循环变量的值，要么改用while循环，要么在for外部先定义变量

死循环

格式：

• for死循环：for(;;) { ... }
• while死循环：while(true) { ... } （最常用，最清晰）
• do-while死循环：do{ ... } while(true);

注意事项：死循环下方的代码会变为“无法访问的语句”，编译错误

2 ) 应用场景

当需要一直执行某任务，直到特定条件触发时才退出（如键盘录入数据，直到用户输入0退出）
此时结合break使用

示例（键盘输入合法性检查）：

while (true) {
    int num = sc.nextInt();
    if (num >= 1 && num <= 100) {
        break;       // 输入合法则跳出死循环 
    }
    System.out.println("输入有误，请重新输入：");
}

跳转控制语句

1 ) continue 跳过本次循环

作用：结束本次循环，立即进行下一次循环的条件判断。

示例（电梯1-24层，4层不停）：

for (int i = 1; i <= 24; i++) {
    if (i == 4) {
        continue;    // 跳过4层的输出 
    }
    System.out.println(i + "层到了~");
}

2 ) break 终止整个循环

作用：立即结束当前循环，不再执行后续循环。
示例（模拟工作到60岁退休）：

for (int i = 20; i <= 80; i++) {
    if (i == 60) {
        break;       // 到60岁终止循环，后面不再上班 
    }
    System.out.println(i + "岁正在上班");
}

break只能在循环和switch中使用；continue只能在循环中使用

循环标号（标签）

默认情况下，break和continue只能控制最内层的循环。
若想跳出外层循环，可使用标号（标签）

语法：

标签名: for/while (...) {
    for/while (...) {
        break 标签名;   // 跳出标签指定的循环 
    }
}

示例（改进的减肥计划）：

用户可多次查询星期对应的减肥计划，输入0时退出

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        lo: while (true) {              // lo 为自定义标签 
            System.out.println("请输入要查看的星期数（0退出）：");
            Scanner sc = new Scanner(System.in);
            int week = sc.nextInt();
            switch (week) {
                case 0:
                    System.out.println("感谢您的使用");
                    break lo;           // 跳出标号为lo的while循环 
                case 1:
                    System.out.println("跑步");
                    break;
                case 2:
                    System.out.println("游泳");
                    break;
                // ... 其他case省略 
                default:
                    System.out.println("输入有误");
                    break;
            }
        }
    }
}

在这个例子中，break lo;会直接结束外层while死循环，而switch中普通的break仅跳出switch
利用标号就能精准控制跳出哪一层

总结

• for：适合明确循环次数，结构紧凑，变量作用域有限
• while：适合条件驱动的循环，循环次数不确定
• do-while：保证至少执行一次，实际开发少用
• 死循环：while(true)最常用，需配合break退出
• 跳转：continue跳过当次，break终止循环，通过标号可跳出任意外层循环

掌握这些循环结构和控制技巧，就能灵活编写各种重复性逻辑，提高代码的简洁性和可读性。