Java死循环和循环嵌套

超高校级の程序员

已于 2024-08-13 11:27:37 修改

阅读量1k

点赞数 21

分类专栏： Java 文章标签： java 开发语言

于 2024-07-24 21:47:42 首次发布

本文链接：https://blog.csdn.net/weixin_64426680/article/details/140673672

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

死循环

死循环，即无限循环。循环一旦开始就永远不会停止。在开发过程中，应当避免死循环。

死循环示例：

死循环示例-for循环

代码：

public static void main(String[] args) {
    for( ; ; ) {
        System.out.println("hello world");
    }
    System.out.println("end");//这行代码永远执行不到
}

上面的示例，没有任何语句控制循环的结束。所以会无限打印hello world，导致循环后面的代码永远执行不到。

注意：如果程序中出现死循环，Eclipse会报错，不允许你执行。

代码：

public static void main(String[] args) {
    for(int i = 0 ; i != 10 ; i += 3 ) {
        System.out.println("hello world");
    }
    System.out.println("end");//这行代码永远执行不到
}

上面的示例，虽然表达式完整，但是 i != 10会永远为真，因此也是一个死循环。导致for循环后面的代码无法执行。

死循环示例-while

代码：

public static void main(String[] args) {
    int i = 0;
    while(i < 100) {
        System.out.println(i);
    }
    System.out.println("end");
}

上面的示例，也是一个死循环，i 初始值是0，在循环体里没有任何操作去改变 i 的值，因此 i < 100永远为真，循环会无限执行，while循环后面的代码永远不会被执行到。很多新手，在写while循环的时候容易漏写i++。

正是这个原因，通常使用for循环不使用while循环。

代码：

public static void main(String[] args) {
    while(true) {
        System.out.println("hello world");
    }
}

这也是一个死循环。循环条件永远是true。

死循环示例-do..while

代码：

public static void main(String[] args) {
    int i = 0;
    do {
        System.out.println(i);
    }while(i < 100);
    System.out.println("end");
}

上面的示例，和while死循环的案例一样，也是因为缺少 i++。

代码：

public static void main(String[] args) {
    do {
        System.out.println("hello world");
    }while(true);
}

这也是一个死循环。循环条件永远是true。

如何避免死循环

1. 对于知道循环次数的情形，使用for循环。----for循环的语法格式，表达式3处写循环控制语句，不容易忘记。while和do..while容易忘记。

2. 写完代码以后，找临界值试试验证代码的正确性。

3. 借助break结束循环。

break、continue关键字

结束循环

结束循环的方式一共有2种：

1. 循环正常结束，即循环条件不再满足时，循环正常结束。

2. 强行结束循环，即break关键字。

在开发中无论是循环的正常结束还是通过break让循环结束，都是非常非常常见的。

break关键字

break关键字一共2个用途：

1. 用在switch..case语句中的每个case里，用于结束switch语句。

2. 用在循环结构的循环体中，用于结束当前循环的执行。即：break写在哪个循环里，就结束哪个循环。

如果break出现在循环体里，break用于结束当前循环。

如果循环体内，break后面还有别的代码，break后面的代码不会执行。----仅限循环体内的代码。循环体外的代码可以正常执行。

如果循环次数尚未用完，执行到了循环体中的break语句，也是直接结束循环，未执行的循环次数不再执行。

break可以出现在for循环里，可以出现在while循环里，也可以出现在do..while循环里。

break示例1：

1. 需求：产生10个[10, 20]之间的随机数，产生随机数的过程中，如果某个随机数的值是16，结束循环。

2. 代码：

public static void main(String[] args) {
//需求：产生10个[10, 20]之间的随机数，产生随机数的过程中，如果某个随机数的值是16，结束循环。
    Random random = new Random();
    for(int i = 0; i < 10; i++) {
        int num = random.nextInt(20 - 10 + 1) + 10;
        System.out.print(num + " ");
        if(num == 16) {
            break;
        }
    }
}

break示例2：

1. 需求：限定用户输入内容。提示用户输入1~7之间（含1和7）的数字。如果用户输入的不是1~7之间的数字，让用户继续输入，如果输入是1~7之间的数，则结束循环。

2. 代码：

public static void main(String[] args) {
//需求：限定用户输入内容。提示用户输入1~7之间（含1和7）的数字。
//如果用户输入的不是1~7之间的数字，让用户继续输入，如果输入是1~7之间的数，则结束循环。
    Scanner scanner = new Scanner(System.in);
    while(true) {
        System.out.print("请输入1~7之间的数字：");
        int num = scanner.nextInt();
        if(num >= 1 && num <= 7) {
            break;
        }else {
            System.out.println("输入的数据有误！");
        }
    }
}

break的使用场景举例：

1. 从数组中查找某个数据，一旦找到，就结束循环。

2. 用在死循环里，用于结束死循环（通常是达到了某个条件）。

3. 游戏里，将游戏中的怪物随机刷新在游戏地图里，如果怪物被刷新到了障碍物里（例如：河、山、树等），重新随机怪物的位置。

break关键字通常情况下和if语句搭配使用。

continue关键字

continue关键字的作用是用于结束本次循环。

例如：循环体里一共有10行代码，第5行出现了continue，当执行完continue以后，本次循环中第6行到第10行代码将不再执行。

continue只是结束本次循环，而不是结束整个循环。continue通常情况下也是与if语句搭配使用。

continue示例：

1. 需求：打印100以内所有的奇数。

2. 代码：

public static void main(String[] args) {
//需求：打印100以内所有的奇数。
    for(int i = 1; i < 100; i++) {
        if(i % 2 == 0) {
            continue;
        }
        System.out.println(i);
    }
}

break、continue总结

1. break用于结束当前循环。

2. continue用于结束本次循环。

3. break、continue通常是与if语句连用。即某种条件满足时才break或continue。

4. break使用比较频繁，经常用在死循环里结束循环。或者用在for循环里提前结束循环。

5. continue很少使用。

循环嵌套

循环嵌套：一个循环作为另外一个循环的循环体或者是循环体的一部分。

for、while、do..while可以相互嵌套。

循环嵌套示例1：

1. 需求：打印如下内容：

1 2 3 4 5

2. 代码：

public static void main(String[] args) {
//需求：打印如下内容：
// 1 2 3 4 5
// 1 2 3 4 5
// 1 2 3 4 5
//方法一：
    System.out.println("1 2 3 4 5 ");
    System.out.println("1 2 3 4 5 ");
    System.out.println("1 2 3 4 5 ");
    System.out.println("-----华丽的分割线-----");
//方法二：
    for(int j = 1; j <= 5; j++) {
        System.out.print(j + " ");
    }
    System.out.println();
    for(int j = 1; j <= 5; j++) {
        System.out.print(j + " ");
    }
    System.out.println();
    for(int j = 1; j <= 5; j++) {
        System.out.print(j + " ");
    }
    System.out.println();
    System.out.println("-----华丽的分割线-----");
//方法三：
    for(int i = 0; i < 3; i++) {
        System.out.println("1 2 3 4 5 ");
    }
    System.out.println("-----华丽的分割线-----");
//方法四：
    for(int i = 0; i < 3; i++) {
        for(int j = 1; j <= 5; j++) {
            System.out.print(j + " ");
        }
        System.out.println();
    }
}

上述案例方法四中：一个循环就作为了另外一个循环体的内容，这就是循环嵌套。外层循环执行1次，内存循环要执行1遍。

循环嵌套示例2：

1. 需求：打印九九乘法表。

1x1=1

1x2=2 2x2=4

1x3=3 2x3=6 3x3=9

...

2. 代码：

public static void main(String[] args) {
// 需求：打印九九乘法表。
// 1x1=1
// 1x2=2 2x2=4
// 1x3=3 2x3=6 3x3=9
// ...
// 不使用嵌套
// 第1行
    for (int j = 1; j <= 1; j++) {
        System.out.print(j + "x" + 1 + "=" + j * 1 + " ");
    }
    System.out.println();
// 第2行
    for (int j = 1; j <= 2; j++) {
        System.out.print(j + "x" + 2 + "=" + j * 2 + " ");
    }
    System.out.println();
// 第3行
    for (int j = 1; j <= 3; j++) {
        System.out.print(j + "x" + 3 + "=" + j * 3 + " ");
    }
    System.out.println();
// 第4行
    for (int j = 1; j <= 4; j++) {
        System.out.print(j + "x" + 4 + "=" + j * 4 + " ");
    }
    System.out.println();
// 第5行
    for (int j = 1; j <= 5; j++) {
        System.out.print(j + "x" + 5 + "=" + j * 5 + " ");
    }
    System.out.println();
// 第6行
    for (int j = 1; j <= 6; j++) {
        System.out.print(j + "x" + 6 + "=" + j * 6 + " ");
    }
    System.out.println();
// 第7行
    for (int j = 1; j <= 7; j++) {
        System.out.print(j + "x" + 7 + "=" + j * 7 + " ");
    }
    System.out.println();
// 第8行
    for (int j = 1; j <= 8; j++) {
        System.out.print(j + "x" + 8 + "=" + j * 8 + " ");
    }
    System.out.println();
// 第9行
    for (int j = 1; j <= 9; j++) {
        System.out.print(j + "x" + 9 + "=" + j * 9 + " ");
    }
    System.out.println();
    System.out.println("-----华丽的分割线-----");
    for(int i = 1; i <= 9; i++) {
        for(int j = 1; j <= i; j++) {
            System.out.print(j + "x" + i + "=" + j * i + " ");
        }
        System.out.println();
    }
}

循环嵌套示例3：

1. 需求：求1! + 2! + 3! + 4!的和是多少。

2. 代码：

public static void main(String[] args) {
//需求：求1! + 2! + 3! + 4!的和是多少。
//分析：
//1.内层循环 计算每个数的阶乘
//2.外层求 阶层的和。
    long sum = 0;
    for(int i = 1; i <= 4; i++) {
        long num = 1;
        for(int j = 1; j <= i; j++) {
            num *= j;
        }
        sum += num;
    }
    System.out.println(sum);
}

循环嵌套示例4：

1. 需求：我国古代数学家张邱建在《算经》中出了一道“百钱买百鸡”的问题，题意是这样的：5文钱可以买一只公鸡，3文钱可以买一只母鸡，1文钱可以买3只小鸡。现在用100文钱买100只鸡，那么各有公鸡、母鸡、小鸡多少只？请编写程序实现。

2. 代码：

public static void main(String[] args) {
/*我国古代数学家张邱建在《算经》中出了一道“百钱买百鸡”的问题，题意是这样的：
5文钱可以买一只公鸡，3文钱可以买一只母鸡，1文钱可以买3只小鸡。
现在用100文钱买100只鸡，那么各有公鸡、母鸡、小鸡多少只？请编写程序实现。
分析：
1. 5文钱买1只公鸡。100文钱最多买20只公鸡。也就是说公鸡的取值范围是：[0,20]
2. 3文钱买1只母鸡。100文钱最多买33只母鸡。也就是说母鸡的取值范围是：[0,33]
3. 1文钱买3只小鸡。100文钱最多买300只小鸡（因为是最多100只鸡，所以最多是100只）。也就是说小鸡的取值范围是：[0,100] 注：小鸡需要3只3只买
假设买了 x只公鸡，y只母鸡，z只小鸡。 5*x + 3*y + z/3 = 100 并且 x + y + z = 100,求x、y、z的组合有哪些*/
    for(int x = 0; x <= 20; x++) {
        for(int y = 0; y <= 33; y++) {
            for(int z = 0; z <= 100; z += 3) {
                if(5 * x + 3 * y + z / 3 == 100 && x + y + z == 100) {
                    System.out.println("公鸡" + x + "只，母鸡" + y + "只， 小鸡" + z + "只");
                }
            }
        }
    }
}