# 循环结构(while/do-while/for)

逻辑：如果…，则再继续…。

循环结构分为当型（while、for）和直到型（do…while）

当型：布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环。

直到型：先执行某语句， 再判断布尔表达式，为true时，就执行反复某语句，当布尔表达式条件为false时才停止循环。

## while循环

格式：

```java
While (布尔表达式) {
    循环体;
}
```

当布尔表达式的结果为true时一直执行循环体内容，直到结果为false时结束循环。

注意：循环体中必须要有使循环结束的语句，复制会出现死循环。

示例：

```java
package com.itcode.demo1;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 需求：while循环加if-else嵌套使用 求1-100奇数之和，偶数之和。 
 *      以后我们做练习最好能把以前的知识结合在一起，锻炼自己的思维能力。 
 */  
public class TestControl5 {  

    public static void main(String[] args) {  

        int i = 0;  
        int count1 = 0; // 奇数和  
        int count2 = 0; // 偶数和  

        while (i <= 100) {  
            // 当i是奇数时就把奇数的值累加到count1。反之则累加到count2。  
            if (i%2 != 0) {  
                count1 += i;  
                i ++;  
            } else {  
                count2 += i;  
                i ++;  
            }  
        }  

        System.out.println("奇数和：" + count1);  
        System.out.println("偶数和：" + count2);  
    }  
}
```

效果：

![](/files/-LxV2SUt_Aq48uZnamM7)

示例二：输入10个人的年龄，判断大于30岁所占的比例

![](/files/-LxV2aw0DY3sxeNMTuYN)

![](/files/-LxV2cxKjd4eBMqU5oku)

## do-while循环

格式：

```java
do{
    循环体;
}While (布尔表达式);
```

概述：先执行某语句， 再判断布尔表达式，为true时，就执行反复某语句，当布尔表达式条件为false时才停止循环。

和while的区别：while是先判断再执行，do…while是先执行再判断。

示例：

```java
package com.itcode.demo1;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 需求：do…while循环版求1-100直接奇数和和偶数和，知道大概格式就行，很少用。 
 */  
public class TestControl6 {  

    public static void main(String[] args) {  

        int i = 0;  
        int count1 = 0; // 奇数和  
        int count2 = 0; // 偶数和  

        do {  
            // 当i是奇数时就把奇数的值累加到count1。反之则累加到count2。  
            if (i%2 == 0) {  
                count2 += i;  
                i++;  
            } else {  
                count1 += i;  
                i++;  
            }  
        } while (i <= 100);  

        System.out.println("奇数和：" + count1);  
        System.out.println("偶数和：" + count2);  
    }  
}
```

## for循环

格式：

```java
for(初始化语句;布尔表达式;迭代因子){
    循环体;
}
```

细节阐述

* 初始化语句：设置循环变量初始化值。
* 布尔表达式：任意布尔表达式都可以。
* 迭代因子：控制循环变量的增减。
* 循环体：输出内容
* **初始化作用域：仅限于for循环内。**

**无限循环**

```java
for (;;) {//类似while(true){}  

}
```

示例：

```java
package com.itcode.demo1;  

import java.util.Scanner;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 键盘录入for循环n*n乘法表 
 */  
public class TestControl7 {  

    public static void main(String[] args) {  

        Scanner scanner = new Scanner(System.in);  
        System.out.println("请输入一个数：");  
        int a = scanner.nextInt();  
        for (int x = 1; x <= a; x++) { // 外循环控制行数  
            for (int y = 1; y <= x; y++) {// 内循环控制列数  
                // System.out.print()与System.out.println();的区别是，System.out.print();不换行。  
                System.out.print(y + "*" + x + "=" + x * y +"\t");  
            }  
            System.out.println();  
        }  
    }  
}
```

> 注意for增强型
>
> for-each/增强for循环不能修改数组元素的值，不涉及索引(下标)的操作。

> ```java
> String[] arr = {"成都", "码到", "功成"};  
>
>         // 普通for循环  
>         for (int i = 0; i < arr.length; i++) {  
>             System.out.println(arr[i]);  
>         }  
>
>         // 增强/for-each循环 只能读取值，不能修改值。  
>         for (String s : arr) {  
>             System.out.println(s);  
>         }  
> ```

## 嵌套循环

概述：在一个循环语句内部再嵌套1-n个循环。while、do-while与for循环相互间可任意嵌套多层。

示例：

```java
package com.itcode.demo1;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 需求：循环嵌套练习2个 
 */  
public class TestControl2 {  

    public static void main(String[] args) {  

        // 1.  
        System.out.println("第一个练习效果：");  

        for (int i = 1; i <= 5; i++) {  
            for (int j = 1; j <= 5; j++) {  
                System.out.print(j + "\t");  
            }  
            System.out.println();  
        }  

        // 2.用while循环或其他循环输出1-1000之间能被5整除的数，且每行输出4个。  
        System.out.println("第二个练习效果：");  

        for (int i = 1; i < 1000; i++) { // 输出1-1000之间  
            if (i%5 == 0) { // 能被5整除的数  
                System.out.print(i + "\t");  
            }  
            if(i%20 == 0){// 每行输出4个， 就是每行输出个数乘以(能被*整除的数)  
                System.out.println();  
            }  
        }  

    }  
}
```

效果：

![](/files/-LxV3IznLUB10QK0wEDs)

## continue，break

* `continue`：略过本次循环之后继续循环。（只能放在循环中，搭配if语句使用）
* `break`：直接终止，剩下的循环不再执行。跳出所在循环或switch语句。（一般用于循环或者switch语句中），想跳出外层循环请使用标签。
* `return`：返回值和结束方法运行。

注意：1.break可以放在任何语句中，比如单独使用if语句必须搭配标签使用。

```
o:if(a=2){
    break o;
}
```

示例：

```java
package com.itcode.demo1;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 需求：contine，break的区别 
 */  
public class TestControl9 {  

    public static void main(String[] args) {  

        // 让我们来看相同条件下continue语句和beak语句运行结果的不同  
        System.out.println("continue语句运行结果：");  
        for (int i = 1; i < 12; i++) {  
            if (i == 7) {  
                continue;// 7不会显示，其它小于12的数字都会显示  
            }  
            System.out.print(i + "\t");  
        }  

        System.out.println();  
        System.out.println("beak语句运行结果：");  
        for (int i = 1; i < 12; i++) {  
            if (i == 7) {  
                break;// 大于6的数字都不会显示  
            }  
            System.out.print(i + "\t");  
        }  
    }  
}
```

效果：

![](/files/-LxV4OqjPrKMKBED6i0Y)

练习：

```java
package com.itcode.demo1;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 需求：contine，break 练习。 
 */  
public class TestControl10 {  

    public static void main(String[] args) {  
        // 把100~150之间不能被3整除的数输出，并且每行输出5个  
        int sum = 0; //计数器  
        for (int i = 100; i < 150; i++) {  
            if (i%3 == 0) {  
                continue;// 如果是三的倍数，跳过  
            }  
            // 反之则输出  
            System.out.print(i+ ",");  
            sum++;// 每输出一个就计一个  
            // 每行的数量达到五个，换行  
            if (sum%5 == 0) {  
                System.out.println();  
            }  
        }  
    }  
}
```

效果：

![](/files/-LxV4XCxFYvKScav_Nd_)

## 带标签的continue/break

简单来讲，标签可以从内循环调到外循环。一般不用，但需要了解。

示例：

```java
package com.itcode.demo;  

import javax.swing.JFrame;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 * 求质数。 
 * 质数：只能被1和自己本身整除的数，1和2不算。 
 * 数学逻辑：如果一个数N从N%2开始，依次N%3，N%4，N%5，N%6……一直n%(小于n/2)其结果都不是0的时候，这个数就是质数。 
 */  
public class TestControl11 {  

    public static void main(String[] args) {  
        /*  
         * 求[101-104)之间的质数  
         * 执行过程： 
         * 注意：到哪一层代码我都用汉字一二三四五表示，让大家更好理解。 
         * ① 验证101 
         * 1.从“一”开始，int i =101, i <104满足条件，继续往下。 
         * 2.来到“二”，j等于2，判断条件2小于101/2，继续往下。 
         * 3.来到“三”，101%2值不等于0，回到“二”，先给j加上1，j的值变成3。3小于101/2，往下执行。 
         * 4.又来到“三”，101%3值不等于0，又回到“二”，j++,j的值变成4。判断4小于101/2。往下执行。 
         * 5.来到“三”，101%4的值不等于0，又回到“三”…… 
         * 6.“三”“二”之间往返遍历判断，也就是“101%5，101%6，101%7，101%8，101%9……”的值是否等于0。 
         * 7.执行到101%49时还不满足不满足i%j==0，还是要继续返回到“二”，49加1等于50。 
         * 8.50不满足j < 101/2（101/2=50,因为j的值是整数型），结束“二”/内循环，来到“五”，打印出101。 
         * ② 验证102 
         * 1.打印完毕回到“一”，执行"i++"，i的值由101变成102。判断102小于104，继续往下。 
         * 2.来到“三”，102%2值等于0。不是质数，进入“三”里面，通过"continue outer;"直接跳到"outer:for(i……"/外循环。 
         * ③ 验证103 
         * 1.执行"i++"，i的值由102变成103。判断103小于104，继续往下。 
         * 2.来到“二”，j等于2，判断条件2小于103/2，继续往下。 
         * 3.来到“三”，103%2值不等于0，回到“二”，先给j加上1，j的值变成3。3小于103/2，往下执行。 
         * 4.又来到“三”，103%3值不等于0，又回到“二”，j++,j的值变成4。判断4小于103/2。往下执行。 
         * 5.来到“三”，103%4的值不等于0，又回到“三”…… 
         * 6.“三”与“二”之间往返遍历判断，也就是“103%5，103%6，103%7，103%8，103%9……”的值是否等于0。 
         * 7.执行到103%50还不满足不满足i%j==0，还是要继续返回到“二”，50加1等于51。 
         * 8.51不满足j < 103/2（103/2=51,因为j的值是整数型），结束“二”/内循环，来到“五”，打印出103。 
         * ④ 结束 
         * 1.打印完毕回到“一”，执行"i++"，i的值由103变成104。判断104小于104不满足，整个循环执行完毕。 
         * 2.所以控制台打印结果就是101和103。 
         * */  

        // 一 外循环，依次遍历[101,104)的值。  
        outer:for(int i=101; i<104; i++) {  

            // 二 内循环 从2开始，依次加一，为“N%2开始，依次N%3，N%4，N%5，N%6……一直n%(小于n/2)”做准备。  
            for(int j=2; j <i/2; j++) {  

                // 三 if语句 验证值是否为质数   
                if(i%j == 0) {  

                    // 四 跳转到外循环。  
                    continue outer;  
                }  
            }  

            // 五 打印出质数。  
            System.out.println(i+"\t");   
        }  
    }  

}
```

效果：

![](/files/-LxV4fFtxHrfMR7L3LVL)

#### 练习

练习1：

![](/files/-LxV4kYTnJil3Ex0YLQz)

效果：

![](/files/-LxV4nwMKTPiVIjQyL14)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://xiaoxiami.gitbook.io/java/javaji-chu/kong-zhi-yu-ju/xun-huan-jie-gou-whiledowhilefor.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.