主题
  • 默认模式
  • 浅蓝色模式
  • 淡绿色模式
  • 深夜模式

Java 循环结构

Java 中的循环结构是一种控制流语句,用于在满足特定条件时重复执行某段代码。

循环结构能够有效地减少代码冗余,提高程序的执行效率,特别适用于需要重复执行相同或相似操作的场景。

通过循环,程序员可以简洁地表达重复性任务,而不必手动编写大量重复的代码。

✅ Java 提供了四种主要的循环结构:

  • while循环:用于处理条件驱动的数学运算,特别是当循环次数不确定但需要满足特定条件时
  • do-while循环:用于必须至少执行一次的数学运算
  • for循环:用于处理已知循环次数的数学运算
  • 增强for循环 (for-each 循环):用于增强for循环专门为遍历数组和集合设计,使代码更简洁

Java while 循环

while 循环最适合处理条件驱动的数学运算,特别是当循环次数不确定但需要满足特定条件时。

✅ 下面是使用while循环完成 1+2+3+...+100 累加的实例:

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        int num = 1;
        while(sum <= 100) {
            sum += num;
            num++;
        }
        System.out.println("最终和:" + sum);
    }
}

💻 运行结果:

最终和:5050

Java do-while 循环

do-while 循环是 Java 中的一种后测试循环结构,它会先执行循环体中的代码,然后再检查循环条件。

这意味着循环体至少会执行一次,即使条件一开始就不满足。

✅ 下面是使用do-while循环实现的猜数字游戏实例:

import java.util.Scanner;
import java.util.Random;

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

        // 生成1-100的随机数
        int secretNumber = random.nextInt(100) + 1;
        int guess;
        int attempts = 0;

        System.out.println("欢迎来到猜数字游戏!");

        do {
            System.out.print("请输入你猜的数字(1-100): ");
            guess = scanner.nextInt();
            attempts++;

            if (guess < secretNumber) {
                System.out.println("太小了!");
            } else if (guess > secretNumber) {
                System.out.println("太大了!");
            }
        } while (guess != secretNumber);

        System.out.println("恭喜你猜对了!用了 " + attempts + " 次尝试。");
        scanner.close();
    }
}

💻 运行结果:

欢迎来到猜数字游戏!
请输入你猜的数字(1-100): 50
太大了!
请输入你猜的数字(1-100): 25
太小了!
请输入你猜的数字(1-100): 37
太大了!
请输入你猜的数字(1-100): 31
恭喜你猜对了!用了 4 次尝试。

Java for 循环

for循环用于在已知循环次数的情况下重复执行代码块。

for循环需要初始化循环控制变量指定循环次数迭代循环控制变量

✅ 下面是使用for循环实现的九九乘法表实例:

public class MultiplicationTable {
    public static void main(String[] args) {
        // 外层循环控制行数(1-9)
        for (int i = 1; i <= 9; i++) {
            // 内层循环控制每行的列数
            for (int j = 1; j <= i; j++) {
                // 格式化输出乘法算式
                System.out.printf("%d×%d=%-2d  ", j, i, i * j);
            }
            // 每行结束后换行
            System.out.println();
        }
    }
}

💻 运行结果:

1×1=1
1×2=2   2×2=4
1×3=3   2×3=6   3×3=9
1×4=4   2×4=8   3×4=12  4×4=16
1×5=5   2×5=10  3×5=15  4×5=20  5×5=25
1×6=6   2×6=12  3×6=18  4×6=24  5×6=30  6×6=36
1×7=7   2×7=14  3×7=21  4×7=28  5×7=35  6×7=42  7×7=49
1×8=8   2×8=16  3×8=24  4×8=32  5×8=40  6×8=48  7×8=56  8×8=64
1×9=9   2×9=18  3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81  

Java 增强 for 循环 (for-each 循环)

Java 的增强 for 循环(也称为 for-each 循环)是 Java 5 引入的一种简化版的迭代语法。

它用于遍历数组和集合元素,使代码更简洁易读。

✅ 下面是使用for-each循环实现的九九乘法表实例:

public class MultiplicationTable {
    public static void main(String[] args) {
        // 创建一个包含1-9的数组
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};

        // 外层增强 for 循环控制行数(1-9)
        for (int i : numbers) {
            // 内层增强 for 循环控制每行的列数
            for (int j : numbers) {
                if (j <= i) {
                    // 格式化输出乘法算式
                    System.out.printf("%d×%d=%-2d  ", j, i, i * j);
                }
            }
            // 每行结束后换行
            System.out.println();
        }
    }
}

💻 运行结果:

1×1=1
1×2=2   2×2=4
1×3=3   2×3=6   3×3=9
1×4=4   2×4=8   3×4=12  4×4=16
1×5=5   2×5=10  3×5=15  4×5=20  5×5=25
1×6=6   2×6=12  3×6=18  4×6=24  5×6=30  6×6=36
1×7=7   2×7=14  3×7=21  4×7=28  5×7=35  6×7=42  7×7=49
1×8=8   2×8=16  3×8=24  4×8=32  5×8=40  6×8=48  7×8=56  8×8=64
1×9=9   2×9=18  3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81

Java break 关键字

break 是 Java 中的一个控制流关键字,主要用于提前终止循环语句或switch语句的执行。

break 执行跳出最近的一层循环(比如:多层循环嵌套的场景),将继续执行该循环后面的语句。

✅ 下面是使用break语句实现的查找数组中偶数实例:

public class ForEachBreakExample {
    public static void main(String[] args) {
        // 定义一个整数数组
        int[] numbers = {1, 3, 5, 8, 7, 10, 12};

        System.out.println("开始查找数组中的第一个偶数...");

        // 使用 for-each 循环遍历数组
        for (int num : numbers) {
            System.out.println("当前检查的数字: " + num);

            // 检查是否为偶数
            if (num % 2 == 0) {
                System.out.println("找到的第一个偶数是: " + num);
                break; // 找到后立即退出循环
            }
        }

        System.out.println("查找结束");
    }
}

💻 运行结果:

开始查找数组中的第一个偶数...
当前检查的数字: 1
当前检查的数字: 3
当前检查的数字: 5
当前检查的数字: 8
找到的第一个偶数是: 8
查找结束

Java continue 关键字

continue 是 Java 中的一个控制流关键字,作用是跳过当前循环的剩余部分,直接进入下一次循环的迭代。

✅ 下面是使用continue实现的统计 1-100 奇数的和实例:

public class ContinueExample2 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            sum += i;
        }
        System.out.println("1-100奇数的和为: " + sum);
    }
}

💻 运行结果:

1-100奇数的和为: 2500


评论区 0
发表评论
教程介绍
Java 通用高级编程语言,广泛应用在企业级应用开发、移动应用开发、大数据处理等领域。
12 章节
22 阅读
0 评论