Day4-第3章 流程控制语句结构（续）

1. 循环语句

什么情况下，需要用到循环结构？

当某些代码需要重复执行时，就需要用到循环结构。

2、循环结构的3种形式

（1）for循环

（2）while循环

（3）do while循环

1.for循环

for循环语句格式：

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

注意：

（1）for(;;)中的两个；是不能多也不能少

（2）循环条件必须是boolean类型

执行流程：

• 第一步：执行初始化语句①，完成循环变量的初始化；

• 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；

  • 如果是true，执行第三步；
  • 如果是false，循环语句中止，循环不再执行。

• 第三步：执行循环体语句③

• 第四步：执行迭代语句④，针对循环变量重新赋值

• 第五步：根据循环变量的新值，重新从第二步开始再执行一遍

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

案例：输出1-5的数字

public class Test01For {
    public static void main(String[] args) {
        for (int i = 1; i <=5; i++) {
            System.out.println(i);
        }
        /*
        执行步骤：
         */
    }
}

2、变量作用域

案例：求1-100的累加和

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);
    }
}

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("我爱你！");
        }
    }
}

思考一下如下代码执行效果：

public class Test03EndlessFor {
    public static void main(String[] args) {
        for (int i=1; i>=10; ){ //??  一次都不执行
            System.out.println("我爱你！");
        }
    }
}

2 关键字break

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

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

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

import java.util.Scanner;
​
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 + "不是素数");
        }
    }
}

3. while循环

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

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

注意：

while(循环条件)中循环条件必须是boolean类型

执行流程：

• 第一步：执行循环条件语句①，看循环条件语句的值是true，还是false；

  • 如果是true，执行第二步；
  • 如果是false，循环语句中止，循环不再执行。

• 第二步：执行循环体语句②；

• 第三步：循环体语句执行完后，重新从第一步开始再执行一遍

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

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

import java.util.Scanner;
​
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();
    }
}
​

2、死循环

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

注意：

（1）while(true)：常量true表示循环条件永远成立

（2）while(循环条件)，如果循环条件中的循环变量值不修改，那么循环条件就会永远成立

（3）while()中的循环条件不能空着

import java.util.Scanner;
​
public class Test05While {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
​
        int positive = 0;
        int negative = 0;
        
        while(true){
            System.out.print("请输入整数（0表示结束）：");
            int num = input.nextInt();
            
            if(num > 0){
                positive++;
            }else if(num < 0){
                negative++;
            }else{
                break;
            }
        }
        System.out.println("正数个数：" + positive);
        System.out.println("负数个数：" + negative);
​
        input.close();
    }
}

思考下面代码的执行效果，为什么？

• 输入0
• 输入1

import java.util.Scanner;
​
public class Test05While {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
​
        int positive = 0;
        int negative = 0;
        
        System.out.print("请输入整数（0表示结束）：");
        int num = input.nextInt();
        
        while(num != 0){   
            if(num > 0){
                positive++;
            }else if(num < 0){
                negative++;
            }
        }
        System.out.println("正数个数：" + positive);
        System.out.println("负数个数：" + negative);
​
        input.close();
    }
}
​

3. 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;
​
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();
    }
}

2、死循环

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

注意：

（1）while(true)：常量true表示循环条件永远成立

（2）while(循环条件)，如果循环条件中的循环变量值不修改，那么循环条件就会永远成立

（3）while()中的循环条件不能空着

import java.util.Scanner;
​
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();
    }
}

4. 循环语句的区别

• 从循环次数角度分析

  • do...while循环至少执行一次循环体语句
  • for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句

• 如何选择

  • 遍历有明显的循环次数（范围）的需求，选择for循环
  • 遍历没有明显的循环次数（范围）的需求，循环while循环
  • 如果循环体语句块至少执行一次，可以考虑使用do...while循环
  • 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

• 三种循环结构都具有四要素：

  • （1）循环变量的初始化表达式
  • （2）循环条件
  • （3）循环变量的修改的迭代表达式
  • （4）循环体语句块

5. 循环嵌套

所谓嵌套循环，是指一个循环的循环体是另一个循环。比如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();
        }
    }

案例2：break结束当层循环

案例：找出1-100之间所有的素数（质数）

提示：素数是指大于1的自然数中，除了1和它本身以外不能再有其他因数的自然数，即某个素数n，在[2,n-1]范围内没有其他自然数可以把n整除

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

6. 关键字：continue

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

分析如下代码运行结果：

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();
        }
    }
}