【大数据】学习笔记 1 Java SE 第3章流程控制语句 3.5 循环语句

青旅半醒 2024-03-22 10:57 38阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第3章 流程控制语句
             *   *  3.5 循环语句
                 *   *  3.5.1 while循环
                     *  3.5.2 do...while循环
                     *  3.5.3 for循环
             *  
             *   *   *  3.5.4 关键字：break
                     *  3.5.5 关键字：continue
                     *  3.5.6 循环语句的区别
                     *  3.5.7 循环嵌套

![在这里插入图片描述][43a00a5b1acb48429f40d8bfa7bc36e0.png_pic_center]

#### 1 Java SE ####

##### 第3章 流程控制语句 #####

###### 3.5 循环语句 ######

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要通过修改循环变量使得循环判断条件为false，从而结束循环，否则循环将一直执行下去，形成死循环。

###### 3.5.1 while循环 ######

1.  while循环语句基本格式：

while (循环条件语句①) {
        
        循环体语句②；
    }

> 注意：
> 
> while(循环条件)中循环条件必须是boolean类型

执行流程：

*  第一步：执行循环条件语句①，看循环条件语句的值是true，还是false；
    
     *  如果是true，执行第二步；
     *  如果是false，循环语句中止，循环不再执行。
 *  第二步：执行循环体语句②；
 *  第三步：循环体语句执行完后，重新从第一步开始再执行一遍

【1】循环条件成立就执行循环体语句

案例：从键盘输入整数，输入0结束，统计输入的正数、负数的个数。

import java.util.Scanner;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Test05While
     * @Author: Ding Jiaxiong
     * @Date:2023/4/22 20:36
     */
    
    public class Test05While {
        
        public static void main(String[] args) {
        
            Scanner input = new Scanner(System.in);
    
            int positive = 0;
            int negative = 0;
            int num = 1; //初始化为特殊值，使得第一次循环条件成立
            while (num != 0) {
        
                System.out.print("请输入整数（0表示结束）：");
                num = input.nextInt();
    
                if (num > 0) {
        
                    positive++;
                } else if (num < 0) {
        
                    negative++;
                }
            }
            System.out.println("正数个数：" + positive);
            System.out.println("负数个数：" + negative);
    
            input.close();
        }
    }

![在这里插入图片描述][30ed76daa4a54e22bd188169ab480559.png_pic_center]

【2】死循环

while(true){
        
         循环体语句;//如果此时循环体中没有跳出循环的语句，就是死循环
    }

> 注意：
> 
> （1）while(true)：常量true表示循环条件永远成立
> 
> （2）while(循环条件)，如果循环条件中的循环变量值不修改，那么循环条件就会永远成立
> 
> （3）while()中的循环条件不能空着

###### 3.5.2 do…while循环 ######

do…while循环语句标准格式：

do {
        
        循环体语句①；
    } while (循环条件语句②)；

> 注意：
> 
> （1）while(循环条件)中循环条件必须是boolean类型
> 
> （2）do\{\}while();最后有一个分号
> 
> （3）do…while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

执行流程：

*  第一步：执行循环体语句①；
 *  第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
    
     *  如果是true，执行第三步；
     *  如果是false，循环语句终止，循环不再执行。
 *  第三步：循环条件语句执行完后，重新从第一步开始再执行一遍

【1】do…while循环至少执行一次循环体

案例：随机生成一个100以内的数，猜这个随机数是多少？

从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，并统计一共猜了多少次

提示：随机数 Math.random()

double num = Math.random();// \[0,1)的小数

import java.util.Scanner;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Test07DoWhile
     * @Author: Ding Jiaxiong
     * @Date:2023/4/22 20:44
     */
    
    public class Test07DoWhile {
        
        public static void main(String[] args) {
        
            //随机生成一个100以内的整数
            /*
            Math.random() ==> [0,1)的小数
            Math.random()* 100 ==> [0,100)的小数
            (int)(Math.random()* 100) ==> [0,100)的整数
            */
            int num = (int) (Math.random() * 100);
            //System.out.println(num);
    
            //声明一个变量，用来存储猜的次数
            int count = 0;
    
            Scanner input = new Scanner(System.in);
            int guess;//提升作用域
            do {
        
                System.out.print("请输入100以内的整数：");
                guess = input.nextInt();
    
                //输入一次，就表示猜了一次
                count++;
    
                if (guess > num) {
        
                    System.out.println("大了");
                } else if (guess < num) {
        
                    System.out.println("小了");
                }
            } while (num != guess);
    
            System.out.println("一共猜了：" + count + "次");
    
            input.close();
        }
    }

![在这里插入图片描述][65cf443dc6f848f99a1d0326a37fbe82.png_pic_center]

【2】死循环

do{
        
         循环体语句;//如果此时循环体中没有跳出循环的语句，就是死循环
    }while(true);

import java.util.Scanner;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Test08EndlessDoWhile
     * @Author: Ding Jiaxiong
     * @Date:2023/4/22 20:46
     */
    
    public class Test08EndlessDoWhile {
        
        public static void main(String[] args) {
        
            //随机生成一个100以内的整数
            /*
            Math.random() ==> [0,1)的小数
            Math.random()* 100 ==> [0,100)的小数
            (int)(Math.random()* 100) ==> [0,100)的整数
            */
            int num = (int) (Math.random() * 100);
            //System.out.println(num);
    
            //声明一个变量，用来存储猜的次数
            int count = 0;
            Scanner input = new Scanner(System.in);
            do {
        
                System.out.print("请输入100以内的整数：");
                int guess = input.nextInt();
    
                //输入一次，就表示猜了一次
                count++;
    
                if (guess > num) {
        
                    System.out.println("猜大了");
                } else if (guess < num) {
        
                    System.out.println("猜小了");
                } else {
        
                    System.out.println("猜对了，一共猜了" + count + "次");
                    break;
                }
            } while (true);
    
            input.close();
        }
    }

![在这里插入图片描述][af97859b851d4b03b68ece9ecff1331e.png_pic_center]

###### 3.5.3 for循环 ######

for循环语句格式：

for(初始化语句①; 循环条件语句②; 迭代语句④){
        
    	循环体语句③
    }

> 注意：
> 
> （1）for(;;)中的两个；是不能多也不能少
> 
> （2）循环条件必须是boolean类型

执行流程：

*  第一步：执行初始化语句①，完成循环变量的初始化；
 *  第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
    
     *  如果是true，执行第三步；
     *  如果是false，循环语句中止，循环不再执行。
 *  第三步：执行循环体语句③
 *  第四步：执行迭代语句④，针对循环变量重新赋值
 *  第五步：根据循环变量的新值，重新从第二步开始再执行一遍

【1】使用for循环重复执行某些语句

案例：输出1-5的数字

/**
     * @Projectname: BigDataStudy
     * @Classname: Test01For
     * @Author: Ding Jiaxiong
     * @Date:2023/4/22 20:47
     */
    
    public class Test01For {
        
        public static void main(String[] args) {
        
            for (int i = 1; i <= 5; i++) {
        
                System.out.println(i);
            }
            /*
            执行步骤：
             */
        }
    }

![在这里插入图片描述][18e11be335764b2184c988d3a3861a01.png_pic_center]

【2】变量作用域

案例：求1-100的累加和

/**
     * @Projectname: BigDataStudy
     * @Classname: Test02ForVariableScope
     * @Author: Ding Jiaxiong
     * @Date:2023/4/22 20:48
     */
    
    public class Test02ForVariableScope {
        
        public static void main(String[] args) {
        
            //考虑变量的作用域
            int sum = 0;
            for (int i = 1; i <= 100; i++) {
        
    //            int sum = 0;
                sum += i;
            }
    //        System.out.println("i = " + i);
            System.out.println("sum = " + sum);
        }
    }

![在这里插入图片描述][f5b75c602bb94fa2ad749cd4b89a3eb7.png_pic_center]

【3】死循环

#####  #####

for(;;){
        
        循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
    }

> 注意：
> 
> （1）如果两个;之间写true的话，就表示循环条件成立
> 
> （2）如果两个;之间的循环条件省略的话，就默认为循环条件成立
> 
> （3）如果循环变量的值不修改，那么循环条件就会永远成立

案例：实现爱你到永远

public class Test03EndlessFor {
        
        public static void main(String[] args) {
        
            for (; ;){
        
                System.out.println("我爱你！");
            }
    //        System.out.println("end");//永远无法到达的语句，编译报错
        }
    }
    
    public class Test03EndlessFor {
        
        public static void main(String[] args) {
        
            for (; true;){
         //条件永远成立
                System.out.println("我爱你！");
            }
        }
    }
    
    
    public class Test03EndlessFor {
        
        public static void main(String[] args) {
        
            for (int i=1; i<=10; ){
         //循环变量没有修改，条件永远成立，死循环
                System.out.println("我爱你！");
            }
        }
    }

###### 3.5.4 关键字：break ######

**使用场景：终止switch或者当前循环**

*  在选择结构switch语句中
 *  在循环语句中
 *  离开使用场景的存在是没有意义的

案例：从键盘输入一个大于1的自然数，判断它是否是素数  
提示：素数是指大于1的自然数中，除了1和它本身以外不能再有其他因数的自然数，即某个素数n，在\[2,n-1\]范围内没有其他自然数可以把n整除

import java.util.Scanner;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Test04Break
     * @Author: Ding Jiaxiong
     * @Date:2023/4/22 20:50
     */
    
    public class Test04Break {
        
        public static void main(String[] args) {
        
            Scanner input = new Scanner(System.in);
    
            System.out.print("请输入一个整数：");
            int num = input.nextInt();
    
            boolean flag = true;//假设num是素数
            //找num不是素数的证据
            for (int i = 2; i < num; i++) {
        //i<=Math.sqrt(num);
                if (num % i == 0) {
        //num被某个i整除了，num就不是素数
                    flag = false;
                    break;//找到其中一个可以把num整除的数，就可以结束了，因为num已经可以判定不是素数了
                }
            }
    
            //只有把[2,num-1]之间的所有数都检查过了，才能下定结论，num是素数
            if (num > 1 && flag) {
        
                System.out.println(num + "是素数");
            } else {
        
                System.out.println(num + "不是素数");
            }
        }
    }

![在这里插入图片描述][cde10405bb46484aae3b2a50a4113d7e.png_pic_center]

###### 3.5.5 关键字：continue ######

**使用场景：提前结束本次循环，继续下一次的循环**

【1】跳过本次循环

分析如下代码运行结果：

public class Test10Continue {
        
        public static void main(String[] args) {
        
            for(int i=1; i<=5; i++){
        
                for(int j=1; j<=5; j++){
        
                    if(i==j){
        
                        continue;
    //                    break;
                    }
                    System.out.print(j);
                }
                System.out.println();
            }
        }
    }

![在这里插入图片描述][69b9ddab6f4d4b988af680b8ad81e432.png_pic_center]

【2】使用continue 提高效率

public class Test10Continue {
        
        public static void main(String[] args) {
        
            //找出1-100之间所有的素数（质数）
            for(int i=2; i<=100; i++){
        
                if(i!=2 && i%2==0 || i!=5 && i%5==0){
        //偶数一定不是素数，
                    continue;
                }
    
                //里面的代码会运行100遍
                //每一遍i的值是不同的，i=2,3,4,5...100
                //每一遍都要判断i是否是素数，如果是，就打印i
    			/*
    			如何判断i是否是素数
    			（1）假设i是素数
    			boolean flag = true;//true代表素数
    			（2）找i不是素数的证据
    			如果在[3,i-1]之间只要有一个数能够把i整除了，说明i就不是素数
    			修改flag = false;
    			这里从3开始找，是因为我们前面排除了偶数
    			（3）判断这个flag
    			*/
                //（1）假设i是素数
                boolean flag = true;//true代表素数
                //（2）找i不是素数的证据
                for(int j=3; j<i; j++){
          // j<=Math.sqrt(i);
                    if(i%j==0){
        
                        flag = false;//找到一个就可以了
                        break;
                    }
                }
                //（3）判断这个flag
                if(flag){
        
                    System.out.println(i);
                }
            }
        }
    }

###### 3.5.6 循环语句的区别 ######

*  从循环次数角度分析
    
     *  do…while循环至少执行一次循环体语句
     *  for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句
 *  如何选择
    
     *  遍历有明显的循环次数（范围）的需求，选择for循环
     *  遍历没有明显的循环次数（范围）的需求，循环while循环
     *  如果循环体语句块至少执行一次，可以考虑使用do…while循环
     *  本质上：三种循环之间完全可以互相转换，都能实现循环的功能
 *  三种循环结构都具有四要素：
    
     *  （1）循环变量的初始化表达式
     *  （2）循环条件
     *  （3）循环变量的修改的迭代表达式
     *  （4）循环体语句块

###### 3.5.7 循环嵌套 ######

**所谓嵌套循环**，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。当然可以是三种循环任意互相嵌套。

例如：两个for嵌套循环格式

for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
        
        for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
        
          	循环体语句⑤;
        }
    }

\*\*执行特点：\*\*外循环执行一次，内循环执行一轮。

【案例1】打印5行直角三角形

*
    **
    ***
    ****
    *****

public static void main(String[] args){
        
    		for (int i = 0; i < 5; i++) {
        
    			for (int j = 0; j <= i; j++) {
        
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    	}

[43a00a5b1acb48429f40d8bfa7bc36e0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3244644de5144713a1d0949d41fecade.png
[30ed76daa4a54e22bd188169ab480559.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5ddcd066b7bf41a6a33e7cb45cad69cb.png
[65cf443dc6f848f99a1d0326a37fbe82.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bd32a6ef1d0748d09e76f48d45154b28.png
[af97859b851d4b03b68ece9ecff1331e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/4d531c65bc854fbfa92961fea00ffa1e.png
[18e11be335764b2184c988d3a3861a01.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/4c4fa639139243feabb3bfccb0403c5a.png
[f5b75c602bb94fa2ad749cd4b89a3eb7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/79c063b474dc46fa849a9bce16654f4e.png
[cde10405bb46484aae3b2a50a4113d7e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b3500e0d710f4be281424335824014ae.png
[69b9ddab6f4d4b988af680b8ad81e432.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d41516584d674120bf2c1ff95f0307ec.png