JavaSE基础day04循环

---

 

一. 流程控制

(一)  循环结构

2.1循环概述

1. 循环 : 如果代码中有重复或者相似的逻辑,可以不用写多次, 使用循环结构, 实现代码在符合条件场景下的多次运行.

2. 循环发生场景案例:

 

3. 循环语法结构: 主要三种,但是重点掌握两种 for  while

 

2.2循环结构之for循环

1.格式:

   for (初始化语句 ; 循环判断条件 ; 初始化语句的变化) {

       循环体语句;

   }

 

2.说明:

        1)初始化语句: 声明一个变量,用于记录循环次数或记录循环起点

        2)循环判断条件: boolean类型表达式,控制循环是否继续执行的条件

        3)初始化语句的变化: 将初始化语句中声明的变量,向着循环不能执行的方向变化

        4)循环体语句: 要重复执行的逻辑内容

 

3.执行流程:

        1)执行初始化语句(循环中的初始化语句只执行一次)

        2)计算循环判断条件

        3)如果计算为false,就结束for循环

        4)如果计算为true,就执行循环体语句

        5)执行初始化语句的变化

        6)回到第2步

4.注意事项:

        1)循环判断条件必须是boolean类型结果

        2)左大括号之前,不要有分号,否则for循环无法控制大括号中的语句.

        3)循环体语句,如果只有一句,那么大括号可以省略,但是建议所有时候都加上大括号,便于代码修改维护. 

 

        案例1: 打印数字1-5

        案例2: 打印数字5-1

        案例3: 计算1-100累加和public class For循环语法 {

public static void main(String[] args) {
        /*
          for(初始化语句; 循环语句判断条件; 初始化语句的变化){
              循环体语句;
          }
          1. 初始化语句: 以变量定义的形式, 设置出一个循环的起点或者表示循环的次数计数

               int i = 1;

          2. 循环语句判断条件: boolean类型的表达式结果, 决定循环是否还能继续运行

             true, 循环继续

             false, 循环结束

          3. 初始化语句的变化: 从循环的起始条件向着循环的终点每次数据变化的过程, ++  --最常见

          4. 循环体语句: 需要反复多次运行的代码逻辑



         */



        // 打印出1-5的所有整数

        /*System.out.println(1);

        System.out.println(2);

        System.out.println(3);

        System.out.println(4);

        System.out.println(5);*/



        /*

            注意事项:

            1. 如果初始化语句定义在for小括号中,那么使用范围就只是当前for循环而已

            2. for循环的小括号后不要有; 否则for循环失效

            3. 如果for循环的循环体 只有一句逻辑代码, 那么for大括号可以省略, 但是不建议省略



         */

        for (int i = 1; i <= 500; i++)
{

            System.out.println(i);

           
System.out.println("hello");

        }



        for (int i = 1; i <= 500; i++)

            System.out.println(i);

            System.out.println("hello");

    }

}

 

public class For循环练习 {
    public static void main(String[] args) {
        // 案例2: 打印数字5-1
        for(int i = 5; i >= 1; i--){
            System.out.println(i);
        }

        // 案例3: 计算1-100累加和
        /*
             1 + 2 + 3... + 100
             1. 需要获取到1-100之间的每一个数字,设计出一个1-100的循环
             2. 在循环中将每次获取到的数据进行累加
         */
        // sum表示1-100数字的累加和结果
        int sum = 0;
        for(int i = 1; i <= 100; i++){
            sum = sum + i;// sum += i;
        }
        System.out.println(sum);
    }
}

2.3循环结构之while循环

1.格式:

        初始化语句;

        while(布尔类型条件表达式) {

               循环体语句;

               初始化语句的变化;

        }

2.执行流程:

        1)初始化语句

        2)计算条件表达式,如果为false,循环直接结束

        3)如果为true,执行循环体语句

        4)执行初始化语句的变化

        5)回到第二步

3.注意事项:

        1)条件表达式必须为boolean类型

        2)左大括号之前不加分号,否则while大括号无效

        3)初始化语句的变化,不要忘记

 

        案例1: 使用while循环打印1-5的数字

        案例2: 使用while循环语句计算1-100累加和

        案例3: 使用while循环语句打印1-100之间所有的偶数

 

public class WhileDemo {
    public static void main(String[] args) {
//        案例1: 使用while循环打印1-5的数字
        for (int i = 1; i <= 5; i++) {
            System.out.println("for---" + i);
        }

        int k = 1;
        while (k <= 5){
            System.out.println("while---" +k);
            k++;
        }

//        案例2: 使用while循环语句计算1-100累加和
         int sum = 0;
         int y = 1;
         while(y <= 100){
            sum += y;
            y++;
         }
         System.out.println(sum);


//        案例3: 使用while循环语句打印1-100之间所有的偶数
         int u = 1;
         while(u <= 100){
             if(u % 2 == 0){
                 System.out.println(u);
             }
             u++;
         }
    }
}

2.4循环结构之do...while循环

1.格式:

        初始化语句;

        do {

                 循环体语句;

               初始化语句的变化;

        } while (循环条件表达式);

2.执行流程:

        1)初始化语句

        2)循环体语句

        3)初始化语句的变化

        4)计算循环条件表达式的值,如果为false,循环结束

        5)如果为true,回到第二步

3.注意事项:   

        1)循环条件表达式必须是boolean类型

        2)while循环条件后面,要有一个分号

 

        案例1: 使用while循环打印5次HelloWorld

        案例2: 使用while循环语句计算1-100累加和

public class DoWhile {
    public static void main(String[] args) {
//        案例1: 使用do..while循环打印5次HelloWorld
        // i值表示需要打印数据的次数
           int i = 1;
           do{
               System.out.println(i);
               i++;
           }while(i <= 5);

//        案例2: 使用do...while循环语句计算1-100累加和
           int sum = 0;
           int k = 1;
           do{
              sum += k;
              k++;
           }while(k <= 100);
           System.out.println(sum);
    }
}

2.5三种循环语句的区别

1.dowhile语句和其他两种语句的区别:

　　1)for循环和while循环先判断条件是否成立,然后决定是否执行循环体（先判断后执行）

        do...while循环先执行一次循环体,然后判断条件是否成立,是否继续执行循环体（先执行后判断）

　　2)dowhile语句至少可以执行一次,另外两种有可能一次都执行不了

 

2.while语句和for的区别:

1) 代码层面: while语句声明的初始化变量,在while结束之后,还能继续使用;

                            for中声明的初始化变量,在for结束之后,就无法使用了.

2) 设计层面: 循环次数确定的话,建议使用for;循环次数不确定建议使用while

public class Test三种循环区别 {
    public static void main(String[] args) {
          for(int i = 10; i <= 5; i++){
              System.out.println(i);
          }

          int k = 10;
          while(k <= 5){
              System.out.println(k);
              k++;
          }

          int y = 10;
          do{
              System.out.println(y);
              y++;
          }while(y <= 5);
    }
}

2.6死循环

1.死循环: 无限循环,循环永远都不停止.

2.格式:

        1)for语句的死循环:

        for ( ; ; ) {

            循环体语句;

        }

        2)while语句的死循环: 常用

        while (true) {

                循环体语句;

        }

 

3.死循环的作用:

        1)在格式上使用了死循环,但是在循环体中,可能出现了需要循环结束的情况,准备了一些跳出、终止循环的跳转语句.

        2)在服务器的设计中,希望服务器永远给我们服务下去,所以需要使用死循环.

 

4.注意事项:

        死循环之后的代码会报错, 因为代码永远不会执行到

public class 死循环 {
    public static void main(String[] args) {
        // 循环判断条件永远为true,这就是一个死循环
        // 正常代码设计不应该出现死循环,导致程序一直运行,不终止
        /*for(;;){
            System.out.println("123");
        }*/

        /*while(true){
            System.out.println("456");
        }*/

        // 注意: 纯粹的死循环之后的代码会报错,无法抵达
      // 死循环永远不结束, 其之后的代码永远没有被执行到的机会, 因此程序报错, 预警
        // System.out.println("456");

        // 使用场景:
        // 1) 循环次数未知需求
        // 2) 不希望代码终止,特意设计出死循环;

        // 因为int数值有范围, 下述代码不是死循环
        int i = 10;
        for(; i <= 100; i-=1000){// -2^31-1  32位
            System.out.println(i);
        }
        System.out.println(i);
    }
}

2.7循环跳转控制语句

跳转语句: 用于结束循环,控制循环的语句.

 

2.7.1 continue继续语句

1.continue语句: continue关键字, 表示继续,下一次,使用在循环中, 结束本次循环,继续下次循环;

        案例: 打印出1-100中所有偶数数据

 

public class ContinueDemo {
    public static void main(String[] args) {
        // 打印出1-100中所有偶数数据
        for(int i = 1; i <= 100; i++){
            // 如果i是奇数, i值不需要打印
            if(i % 2 != 0){
                // 结束本次循环, 继续进行下一次循环
                // 当循环执行到continue关键字, 当前本次循环不再继续运行, 直接进入到下一次循环执行i++
                // continue关键字的作用: 在循环执行过程中, 可以进行筛选, 但无法解决死循环问题
                continue;
            }
            System.out.println(i);
        }
    }
}

2.7.2 break终止语句

1.break语句:  break是关键字, 表示结束, 破坏

                 1)终止switch语句

                 2)结束当前层次循环

 

案例: 模拟用户登录界面,正确用户名为:123,正确的密码为:456,通过键盘录入登录所需的用户名和密码,如果输入数据正确,显示登录成功;如果输入数据有误,支持无限次输入用户名和密码,直到输入正确数据,登录成功为止.

import java.util.Scanner;
public class BreakDemo {
    public static void main(String[] args) {
        // rightName正确用户名
        int rightName = 123;
        // rightPassword正确密码
        int rightPassword = 456;
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请输入用户名:");
            int inName = sc.nextInt();
            System.out.println("请输入密码:");
            int inPassword = sc.nextInt();
            if(inName == rightName && inPassword == rightPassword){
                System.out.println("登录成功");
                // 关键字作用: 直接结束一个循环
                break;
            }else{
                System.out.println("登录失败");
            }
        }
    }
}

 

break在switch和循环中结合使用案例

public class Break练习 {
    public static void main(String[] args) {
        for(int i = 1; i <= 5; i++){
            switch(i){
                case 1:
                    System.out.println("匹配1");
                    // break结束switch分支语句
                    break;
                case 2:
                    System.out.println("匹配2");
                    break;
                case 3:
                    System.out.println("匹配3");
                    break;
                case 4:
                    System.out.println("匹配4");
                    break;
                case 5:
                    System.out.println("匹配5");
                    break;
                default:
                    System.out.println("结束");
            }
            if(i == 2){
                // 结束for循环语句
                break;
            }
        }
    }
}

2.8嵌套循环

1.嵌套循环: 一个循环的循环体是另一个循环.比如for循环里面还有一个for循环,这就是嵌套循环.

           嵌套循环总的循环次数 = 外循环次数 * 内循环次数;

 

2.嵌套循环格式:

   for(初始化语句①; 循环条件②; 初始化语句变化⑦) { // 外层循环(外循环)

      for(初始化语句1③; 循环条件④; 初始化语句1变化⑥) {// 内层循环(内循环)

           执行语句⑤;

      }

   }

 

3.嵌套循环执行流程:

        1)执行顺序: ①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥

        2)说明: 外循环一次,内循环多次(一圈),外循环判断条件为false,嵌套循环结束

 

public class 嵌套循环 {
    public static void main(String[] args) {
        // 总结: 1. 嵌套循环执行过程: 外层循环执行一次,内层循环执行一圈(执行完毕)
        // 2. 嵌套循环的执行总次数: 外层循环次数 * 内存循环次数
        // 3. 嵌套循环执行结束时机: 外层循环判断条件为false
        for(int i = 1; i <= 3; i++){ // 教练发送指令次数,外循环
            for(int j = 1; j <= 5; j++){ // 内循环
                System.out.println("教练第"+ i + "次指令,目前学员跑到第" + j + "圈");
            }
        }
    }
}

案例1: 使用嵌套循环,打印四行五列星星矩形

      *****

      *****

      *****

      *****

public class 矩形星星打印 {
    public static void main(String[] args) {

        // 1. 将 ***** 看做一个字符串整体
      // 一共需要打印出4行, 那么设计出一个4次的循
环, 每次循环中打印出星星字符串
        for(int i = 1; i <= 4; i++){
            System.out.println("*****");
        }

        System.out.println("----------------------------");

        // 2. 将每一个*看成一个独立的个体
        // 一共需要打印4行, 每一行中需要打印5个星星
        for(int i = 1; i <= 4; i++){
            for(int j = 1; j <= 5; j++){
               // 标准的输出语句: System.out.println 表示数据输出后有一次回车换行
                // 如果只想输出数据, 不能换行: System.out.print
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

案例2: 使用嵌套循环,打印5行5列的直角三角形

      *

      **

      ***

      ****

      *****

public class 直角星星打印 {
    public static void main(String[] args) {
        /*
             分析
             1. 一共需要打印5行,设计出一个5次循环
             2. 每一行打印星星规律: 星星的个数与目前正在打印行数一致
                第一行: 1个
                第二行: 2个
                第三个: 3个
                第四行: 4个
                第五行: 5个
         */
        // i表示当前正在输出打印的行数(第几行)
        for(int i = 1; i <= 5; i++){
           for(int j = 1; j <= i; j++){
               System.out.print("*");
           }
            System.out.println();
        }
    }
}

扩展案例: break在嵌套循环中的使用

public class Break在嵌套循环中的使用 {
    public static void main(String[] args) {
        // 教练让学员跑圈,教练员一共发送5次指令,预计每次让学员跑5圈,实际上学员每次接到指令后
        // 只跑3圈, 将上述过程用代码实现出来
        for(int i = 1; i <= 5; i++){// 教练员一共发送5次指令的过程, i值表示第几次指令
            for(int j = 1; j <= 5; j++){
               System.out.println("教练第" + i + "次发出指令, 学员目前跑到第" + j + "圈");
                if(j == 3){
                    /*
                        break关键字, 每次只能结束一个层次的循环; 结束的就是包含break离break最近的一层
                     */
                    break;
                }
            }
        }
    }
}

案例3: 打印99乘法表

      1*1=1

      1*2=2  2*2=4

      1*3=3  2*3=6      3*3=9

      ........................................

      1*9=9  2*9=18    3*9=27    ..........       8*9=72    9*9=81 

public class 九九乘法表 {
    public static void main(String[] args) {
       /* 
        分析
        1. 一共需要输出打印9行数据, 因此设计出一个9次的循环, 表示目前正在打印第几行
        2. 每一行中打印的数据,都是乘法运算, 第一个乘数从1开始到行数终止; 第二个乘数就是当前行数
           1*1=1
           1*2=2   2*2=4
           1*3=3   2*3=6  3*3=9
           ...

           *
           **
           ***
           ****
        */
        for(int i = 1; i <= 9; i++){// i表示目前正在打印的第几行
            for(int j = 1; j <= i; j++){// j表示表达式中的第一个乘数
                System.out.print(j + "*" + i + "=" + j * i + "  ");
            }
            System.out.println();
        }
    }
}

2.9循环综合练习

案例1: 计算1-100的偶数和

public class 循环偶数求和案例 {
    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(sum);


        int sum1 = 0;
        for(int i = 1; i <= 100; i++){
            // 过滤掉所有的奇数数据
            if(i % 2 == 0){
                sum1 += i;
            }
        }

        System.out.println(sum1);
    }
}

案例2: 列举所有的“四叶玫瑰数”,并统计四叶玫瑰数的个数

      (四叶玫瑰数: 是一个四位数,各个位的数字的四次方的和,为该数字本身)

public class 四叶玫瑰案例 {
    public static void main(String[] args) {

        // count表示符合规则的四叶玫瑰数的个数
        int count = 0;
        for(int i = 1000; i<= 9999; i++){
            // 1. 求四位数的个位
            int ge = i % 10;
            // 2. 求四位数的十位
            int shi = i / 10 % 10;
            // 3. 求四位数的百位
            int bai = i / 100 % 10;
            // 4. 求四位数的千位
            int qian = i / 1000;
            // 5. 计算出各个位上4次方的和
            int number = ge*ge*ge*ge + shi*shi*shi*shi + bai*bai*bai*bai + qian*qian*qian*qian;
            // 6. 验证number数据是否与i值本身相等
            if(number == i){
                System.out.println(i);
                count++;
            }
        }

        System.out.println("四叶玫瑰一共有: " + count);
    }
}