04 Java流程控制-循环(while+for+关键字+嵌套)

简介: 04 Java流程控制-循环(while+for+关键字+嵌套)

4 流程控制(循环)

概念

Java中基础编码结构“顺序、分支和循环”,这个编码过程中顺序结构是占主导,可以通过分支结 构,改变顺序结构中执行代码的操作和提供对逻辑判断条件判断操作从而可以达到让代码选择性 执行某段代码的目的,分支结构也好还是顺序结构也好,我们代码只能运行一次,如果出现需要 将某些代码重复性执行多次,以现在代码结构而言是无法完成,当我们遇到代码中某段程序需要 重复性执行的之后,就可以使用Java中提供一种程序结构来完成这个操作,这个结构是循环结构。


例如:开发一个机器人踢足球程序,程序中会有一个问题,如果没有进入到射门范围内,此时就 需要让机器人持续的带球,重复性操作就是持续带球

 使用循环结构可以轻松控制某些事情(操作)重复,重复在重复性操作

Java中提供循环结构有**“while循环、do-while循环 和 for循环”**


所以在编写循环的时候主要提供要素【必要条件】,就要可以在代码结构中添加循环操作,让代码执行重复性操作


循环组成部分:


初始部分:对循环变量赋初值

循环条件:判断循环变量是否超出某个界限

循环操作:要循环执行的具体逻辑

更新变量:修改循环变量的值

4.1while循环

while循环在以后开发中占比0.9%左右【书写while循环比例也就是在0.9%】,但是是一个经典的 循环结构,利用这循环结构完成某些代码重复执行

4.1.1 语法:

语法:


循环变量初值;


while(循环条件){【使用循环变量与某个值组成】


执行语句【让循环重复执行的操作】;


循环变量控制【循环变量的自增或自减】


}


执行流程:


先对布尔表达式进行判断,结果为true,则执行逻辑代码。

本次执行完毕后,再次进行判断,结果仍旧为true,则再次执行逻辑代码。

直至布尔表达式的结果为false时,才会退出循环结构,执行后续代码。

while(布尔表达式){
  //逻辑代码(循环操作)
}
4.1.2 详细说明:
  1. 循环变量赋初值,这个变量主要作用是组成循环条件,可以参与到循环体计算与打印
  2. 循环条件: 使用循环变量与某个值构建一个循环的范围,这个范围也就是循环次数

因为是范围的存在,所以循环条件多使用的**“关系表达式 即 常用关系运算符 > 、>= 、< 、<=” 来组成循环范围**,偶尔可见**使用逻辑运算符与关系运算符共同组成表达式作为循环范围 或者使用 == 或 != 来组建这个循环范围 **

既然循环条件使用关系或逻辑运算符的表达式,所以条件得到结果值只有true 或 false

23.执行语句其实就是你要让循环重复什么代码,这个代码时泛指**【打印语句、逻辑计算、分支 语句或者循环语句】**

4.循环变量控制,因为使用循环变量与某个值构建循环范围,所有需要对循环变量加以控制**【自增或自减】,以让循环条件可以达到我们需要的循环次数**

示例:使用while循环打印1~10之间所有数据

public class WhileDemo {
  //提供While循环的使用
  public static void main(String[] args) {
    //使用while循环打印1~10之间所有数据
    /*
    分析:
    1.重复操作事情 ---》 【打印数据】
    2.重复操作的次数 ---》【打印1到10】应该是10个数字,重复10次
    */
    //循环变量赋初值【定义循环开始的位置】
    int i = 1;
    //只要循环条件为true值循环就会执行,只有当循环条件为false时循环才会停止
    while (i<=10){ //循环条件
    //重复操作的事情
    System.out.println(i);
    //控制循环变量【需要让i变量进行自增操作 ++】
    i++;
    }
  }
}

案例:利用while循环计算100以内(包括100),所有的奇数、偶数和3的倍数


**if 单分支 ** (每一个数都需要判断3次)


三个条件 – if-else if —? 不可以,因为if-else if原则 只要有一个条件判断为true,剩余条件皆不判断

就会出现少一个打印结果情况


----选择if单分支

public class Demo {
    public static void main(String[] args) {
        //利用while循环计算100以内(包括100),所有的奇数、偶数和3的倍数
        /*
        分析:
        1.重复操作的事情 ---》 需要提供判断数据是否是奇数、偶数和3的倍数
            如果需要提供所有的奇数、偶数和3的倍数都要打印出来,此时应该提供一个什么样if判断是合理?
            三个条件 ---》 if-else if ---》不可以,因为if-else if原则 只要有一个条件判断为true,剩余条件皆不判断
                就会出现少一个打印结果情况 --》 那么应该选用谁?
        2.重复的次数 --》 从1~100之间的所有数据 ---》 100次
        */
        //循环变量赋初值
        int i = 1;
        while(i<=100){ //循环条件
        //重复操作的事情
        //先提供if-else if分支判断 --》无法完成具体需求,每个数只判断一次,只输出奇偶数
        //修改为 if 单分支
            if(i %2 == 0){
                System.out.println("偶数:"+i);
            }
            if(i%2 == 1){
                System.out.println("奇数:"+i);
            }
            if(i%3 ==0){
                System.out.println("3的倍数:"+i);

            }
            //循环变量控制
            i++;
        }
    }
}
//
奇数:1
偶数:2
奇数:3
3的倍数:3
偶数:4
奇数:5
偶数:6
3的倍数:6
奇数:7
    .....
3的倍数:96
奇数:97
偶数:98
奇数:99
3的倍数:99
偶数:100

输入一个数,求得这个数是几位数

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数数字");
        int num = sc.nextInt();
        int temp = num;
        if (num==0){
            System.out.println(temp +"是1位数");
        }else{
            //定义一个变量用于保存循环的次数
             int count = 0;
             while (num!=0) {
                 num = num / 10;
                 //每次循环次数+1
                 count++;
             }
            System.out.println(temp+"是"+count+"位数");
        }        
    }
}
4.2 do while循环

do-while循环也是循环结构中一种,do-while循环在语法上看与while循环比较相近,类似于while循环语法“倒立”来实现,do-while循环开发中占比0.1%【在开发中使用do-while这种循环结构的语法较少】

4.1.1 语法

语法:

循环变量赋初值;

do{

执行语句【重复操作的代码】;

循环变量自增或自减【循环变量控制】;

}while(循环条件);

4.2.2 详细说明
  1. 循环变量赋初值,这个变量主要作用是组成循环条件,可以参与到循环体计算与打印

因为是范围的存在,所以循环条件多使用的**“关系表达式 即 常用关系运算符 > 、>= 、< 、<=” 来组成循环范围**,偶尔可见使用逻辑运算符与关系运算符共同组成表达式作为循环范围 或者使用 == 或 != 来组建这个循环范围

既然循环条件使用关系或逻辑运算符的表达式,所以条件得到结果值只有true 或 false

  1. 循环条件: 使用循环变量与某个值构建一个循环的范围,这个范围也就是循环次数
  2. 执行语句:其实就是你要让循环重复什么代码,这个代码时泛指**【打印语句、逻辑计算、分支语句或者循环语句】**
  3. 循环变量控制:因为使用循环变量与某个值构建循环范围,所有需要对循环变量加以控制**【自增或自检】,以让循环条件可以达到我们需要的循环次数**

常见的自增或自检操作使用**“++ 或 – 运算符”,偶尔可见使用运算符“+=、-=、*= 、= 运算符“**

PS:在书写do-while循环的时候一定要注意循环末尾的【;】一要添加

案例:使用do-while循环打印1~10之间所有数据

public class Demo {
    public static void main(String[] args) {
        //使用do-while循环打印1~10之间所有数据
        //1.提供循环变量赋初值
        int i = 1;
        do{
            //重复操作的事情
            System.out.println(i);
            //控制循环变量
            i++;
        }while (i<=10);
        //只要循环条件true就执行循环,只有当循环条件为false停止循环
    }
}

案例:学生根据老师的评语,是否继续敲代码,直到测评为ok,就结束

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String result;
        do{
            System.out.println("敲代码ing...你看我的代码怎么样???");
            System.out.println("评价:");
            result = sc.next();
        }while (!result.equals("ok"));
    }
}
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        String result = sc.next();
        do{
            System.out.println("敲代码ing...你看我的代码怎么样???");
            System.out.println("评价:");
        }while (!result.equals("ok"));
    }
}
4.2.2 do-while与其它两个循环的不同

do-while循环特点就是先执行操作,然后在执行判断,

while循环和for循环都是需要先执行判断,然后再执行操作

所以就算在判断条件不成立的前提下do-while循环依旧会执行一次

而while和for循环是不会执行的

public class Demo {
    public static void main(String[] args) {
        //在同等条件下使用while循环和do-while进行数据打印操作
        //将正常案例操作注释,提供特条件,无论是while还是do-while都设置条件为 <= 0
        System.out.println("----------while-----------");
//        int i =1;
//        while (i<=5){
//            System.out.println(i);
//            i++;
//        }
          int i=1;
          while (i<=0){
              System.out.println(i);
              i++;
          }
          //false,直接退出循环,输出空


        System.out.println("----------do while-----------");
//        int j =1;
//        do{
//            System.out.println(j);
//            j++;
//        }while (j<=5);
            int j =1;
            do{
                System.out.println(j);
            j++;
            }while (j<=0);
            //先输出j=1,再判断,输出1
    }
}

4.3 for循环(重要)

for循环也是循环结构中一种,而且这个循环在开发中占比极高(99%),因为for循环将所有循环使用条件进行归纳,所以循环语句看起来就更加简洁,所以开发者就更加偏向于使用for循环

4.3.1 语法

语法:

for(循环变量赋初值;循环条件;循环变量自增或自减){

重复执行操作【执行语句】;

}

4.3.2 详细说明
  1. 循环变量赋初值,这个变量主要作用是组成循环条件,可以参与到循环体计算与打印
  2. 循环条件: 使用循环变量与某个值构建一个循环的范围,这个范围也就是循环次数

因为是范围的存在,所以循环条件多使用的**“关系表达式 即 常用关系运算符 > 、>= 、< 、<=” 来组成循环范围**,偶尔可见使用逻辑运算符与关系运算符共同组成表达式作为循环范围 或者使用 == 或 != 来组建这个循环范围

既然循环条件使用关系或逻辑运算符的表达式,所以条件得到结果值只有true 或 false

3.执行语句其实就是你要让循环重复什么代码,这个代码时泛指**【打印语句、逻辑计算、分支 语句或者循环语句】**

4.循环变量控制,因为使用循环变量与某个值构建循环范围,所有需要对循环变量加以控制【自增或自检】,以让循环条件可以达到我们需要的循环次数

常见的自增或自检操作使用**“++ 或 – 运算符”,偶尔可见使用运算符“+=、-=、*= 、\= 运算符“**


PS: for循环在书写过程中需要在小括号内使用【;】分隔不同的循环条件


for循环中将循环变量赋初值定义在小括号内,而不像while和do-while将循环变量赋初值定义 在循环外部,所以for循环中循环变量只能在循环体内中使用【在没有使用变形语法之前】

案例:使用for循环完成1-10之间打印【不包括10】

public class Demo {
    public static void main(String[] args) {
        //使用for循环完成1-10之间打印【不包括10】
        //循环变量赋初值;循环条件;循环变量控制
        for (int i = 1; i <10 ; i++) {
            System.out.println(i);
        }
        //因为将循环变量付出值定义在循环体的内部,所以无法在for外部使用到这个循环变量
        //Cannot resolve symbol 'i' IDEA会提示你 找不到i这个变量
        //System.out.println(i);
    }
}

案例:使用for循环完成 1~100之间所有数据之和【包括100】

public class Demo {
    public static void main(String[] args) {
        //使用for循环完成 1~100之间所有数据之和【包括100】
        //提供一个存储累加结果的变量
        int sum = 0;
        for (int i = 1; i <100 ; i++) {
            sum = sum +i;
        }
        System.out.println(sum);
    }
}
4.3.3 for循环的6种写法

因for循环在开中使用的频率是比较高,为了满足for循环对于不同场景的应用,可以将for循环进行6中变形,以适用于不通过操作场景.

package JavaseDemo;

/**
 * description: never-bug
 */
public class Demo {
    //for循环6种写法
    public static void main(String[] args) {
        //1.标准方式
        for(int i = 0 ; i<10;i++){
            System.out.println(i);
        }
        System.out.println("----------------------------------------------");
        //2.因为for循环是将循环变量定义在循环小括号中,所以外界无法使用,如果要外界可以使用i变量
        //将for循环循环变量赋初值的定义提高到for循环的外部,这样for外部就可以使用到循环变量
        //2.1 不在小括号中省略不定义,而是在循环外部定义与赋值
        int i = 0;
        for (;i<10;i++){
            System.out.println(i);
        }
        //2.2 不在小括号中省略不定义,但是在小括号中进行赋值,在for循环外部进行定义
        int j;
        for (j = 0; j<10;j++){
            System.out.println(j);
        }
        //3.循环变量的控制不在小括号内声明【在小括号内省略】,在大括号内提供
        for(int m = 0 ; m <10;){
            System.out.println(m);
            m++;
        }
        //4.for循环变量while循环,将循环变量赋初值和循环变量的控制分别定义在循环的外部和内部,在小括号中省略
        int n = 0;
        for (;n<10;){
            System.out.println(n);
            n++;
        }
        //5.for循环的死循环写法1 【不提供循环条件,默认认为条件为true】
        /*
        什么是死循环? --循环会一直执行,循环条件始终为true,这样循环称之为死循环
        在某些书写循环的操作中,无法明确得知循环次数,此时就可以使用死循环完成循环操作,还要配合关键字break停止循环

        Java中提供三个循环都可以书写死循环
        while对应死循环版本
        while(true){ // 让循环条件始终为true
        }
        do-while对应死循环版本
        do{
        }while(true);// 让循环条件始终为true
        */
        //***for循环不提供循环条件,默认认为条件为true***
        for(int p = 0;;p++){
            System.out.println(p);
        }
        //6.for循环的死循环写法2  【完全省略】,在for循环小括号什么都不定义
        /*
         for(;;){
        System.out.println("我是死循环");
        }
        */
    }
}

  • 总结 for循环的6种写法

//for循环的6种写法


//2.因为for循环是将循环变量定义在循环小括号中,所以外界无法使用,如果要外界可以使用i


变量


//将for循环循环变量赋初值的定义提高到for循环的外部,这样for外部就可以使用到循环变量


//2.1 不在小括号中省略不定义,而是在循环外部定义与赋值


i


//2.2 不在小括号中省略不定义,但是在小括号中进行赋值,在for循环外部进行定义


//3.循环变量的控制不在小括号内声明【在小括号内省略】,在大括号内提供for(int m = 0 ; m <10;){


System.out.println(m); m++;


}


//4.for循环变量while循环,将循环变量赋初值和循环变量的控制分别定义在循环的外部和内 部,在小括号中省略


int n = 0; for (;n<10;){


System.out.println(n); n++;


}


//5.for循环的死循环写法


/*


什么是死循环? --》 循环会一直执行,循环条件始终为true,这样循环称之为死循环


在某些书写循环的操作中,无法明确得知循环次数,此时就可以使用死循环完成循环操作,还要配 合关键字break停止循环


Java中提供三个循环都可以书写死循环while对应死循环版本


while(true){ // 让循环条件始终为true


}

4.4 break和continue关键字(流程控制关键字)

除了通过循环条件可以控制循环之外,还可以通过break和continue关键字进行循环的控制操作

4.4.1 break关键字

break关键字的作用:停止【终止】当前循环,使用break关键字之后,无需等待循环条件为false

在停止循环,只需在循环体中使用break关键字就可以停止循环执行

PS:当前循环是break使用在什么位置,这个循环就是当前循环

使用这个关键字的时机是,不需要等待循环条件为false时停止循环,就可以使用break关键字

案例:计算16~100之间能被15整除的最小值

public class Demo {
    //计算16~100之间能被15整除的最小值
    public static void main(String[] args) {
        //break操作案例:计算16~100之间能被15整除的最小值
        for(int i = 16 ; i<100; i++){
            if(i%15 == 0){//将15整除了
                System.out.println(i);
            //当获得最小值30的时候就不需要让循环继续执行了,停止循环而不是等到循环条件为false停止
                break;
                // 当System.out.print(" "+i); 且无break;输出 30 45 60 75 90
            }
        }
    }
}
4.4.2 continue关键字

continue关键字和break关键字有本质上区别,continue关键字并不会完全终止循环,而是跳过(终止)本次循环,开启下一次循环,就算在循环中使用了continue关键字,循环停止也是根据 循环条件为false时才会停止

 使用这个关键字的使用时机,需要在循环执行过程中,某些次数循环不执行,而不是整体停止循 环,那么就可以continue关键字

案例:模拟电梯上行过程(1-24层),除了第4层不停止之外,剩余都停止(除了4不打印之外,剩余都

打印)

public class Demo {
    public static void main(String[] args) {
        //continue操作案例:模拟电梯上行过程(1-24层),除了第4层不停止之外,剩余都停止(除了4不打印之外,剩余都打印)
        for(int i = 1 ; i<=24;i++){
            if (i == 4){
                continue;  //跳过4
            }
            System.out.println(i);
        }
    }
}
4.5 嵌套循环

循环的嵌套就和分支语句嵌套是一样,允许在循环的内部执行语句中在书写一个循环,在整个循环结构中所有循环语句都可以互相嵌套,但是for循环在开发中占比最高,所以以for循环为例, 循环嵌套


循环嵌套的理解其实就是在原有执行语句的位置【即重复操作的代码】,书写不是“打印、计算或 分支语句”,而是提供了一个新的循环,这样形式就是循环嵌套


循环嵌套中有一个经典的理论:外层循环执行一次,内层循环执行多次


某些操作中提供一层循环是无法满足所有循环逻辑,所以在这样前提下,我们就需要提供嵌套循 环了


需求:打印下面样式


1 2 3 4 5


2 4 6 8 10


3 6 9 12 15


4 8 12 16 20

public class A{
    public static void main(String[] args) {
        /*
        1 2 3 4 5
        2 4 6 8 10
        3 6 9 12 15
        4 8 12 16 20
        */
        //外层循环中 变量是可以参与到 内层循环计算中
        // 参与到 内层循环中 j的赋值、 j的循环条件和参与到内层循环的重复执行操作中
        for(int i = 1 ; i<=4;i++) {
            for (int j = 1; j <= 5; j++) {
        /*
        可以在打印语句中添加 “\t” 代表4个空格 也是键盘上tab键
         */
                System.out.print(j*i + "\t\t");
            }
            //调用一个带有ln方法进行打印,添加换行操作
            System.out.println();
        }
    }
}

可以将当前代码中这种循环形式理解为在看书,外层第一层循环【i层】相当于是书中页数,内层


(第二层)循环【j层】相当于书页作用内一行内容,只有当书中每一行内容都看完之后,才可以 翻页即只有内层循环执行完毕之后,外层循环才会开启下一次


执行流程:当前代码执行到嵌套循环时,首先先执行外层循环的循环变量赋初值【执行1次】,判 断外层循环循环条件是否成立,如果成立就执行大括号中的,内层循环,先执行循环变量赋初值


【随外层循环的次数而进行初始化】,然后判断内层循环的循环条件,如果为true,就执行内层 循环中大括号内执行语句,然后内层循环变量自增或自减,再次执行内层循环条件判断,直到循 环条件为false,内层循环停止,此时外层循环开始循环变量自增或自减,然后再判断外层循环条 件,如果为true,就会再次开启内层循环,否则循环完全结束


PS:外层循环变量是可以参与到内层循环操作的,可以影响内层循环条件,参与到内存循环计算

目录
相关文章
|
5天前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
Java 并发编程——volatile 关键字解析
|
5天前
|
缓存 安全 Java
Java volatile关键字:你真的懂了吗?
`volatile` 是 Java 中的轻量级同步机制,主要用于保证多线程环境下共享变量的可见性和防止指令重排。它确保一个线程对 `volatile` 变量的修改能立即被其他线程看到,但不能保证原子性。典型应用场景包括状态标记、双重检查锁定和安全发布对象等。`volatile` 适用于布尔型、字节型等简单类型及引用类型,不适用于 `long` 和 `double` 类型。与 `synchronized` 不同,`volatile` 不提供互斥性,因此在需要互斥的场景下不能替代 `synchronized`。
2069 3
|
1月前
|
Java 程序员 API
Java循环操作哪个快?
本文探讨了Java中stream API与传统for循环在性能上的对比,通过多个示例分析了不同场景下两者的优劣。作者指出,尽管stream API使代码更简洁,但不当使用会降低可读性和性能,特别是在处理大数据量时。实验结果显示,在多数情况下,普通for循环的性能优于stream API,尤其是在单次操作耗时较短但需多次执行的场景中。文章建议开发者在设计初期就考虑全局流程,避免重复使用stream流,以提升代码质量和性能。
Java循环操作哪个快?
|
1月前
|
Java 程序员 API
Java循环操作哪个快?
本文探讨了Java中Stream API与传统for循环的性能对比及适用场景。作者通过实际案例分析,指出在某些情况下,过度使用Stream API会导致代码可读性和维护性下降。测试结果显示,在数据量较小的情况下,普通for循环的性能优于Stream API,尤其是在涉及多次类似操作时。因此,建议在开发中根据具体需求选择合适的遍历方式,以提高代码的可读性和性能。
Java循环操作哪个快?
|
28天前
|
缓存 监控 Java
Java线程池提交任务流程底层源码与源码解析
【11月更文挑战第30天】嘿,各位技术爱好者们,今天咱们来聊聊Java线程池提交任务的底层源码与源码解析。作为一个资深的Java开发者,我相信你一定对线程池并不陌生。线程池作为并发编程中的一大利器,其重要性不言而喻。今天,我将以对话的方式,带你一步步深入线程池的奥秘,从概述到功能点,再到背景和业务点,最后到底层原理和示例,让你对线程池有一个全新的认识。
55 12
|
1月前
|
JavaScript 前端开发 Java
java中的this关键字
欢迎来到我的博客,我是瑞雨溪,一名热爱JavaScript与Vue的大一学生。自学前端2年半,正向全栈进发。若我的文章对你有帮助,欢迎关注,持续更新中!🎉🎉🎉
53 9
|
1月前
|
设计模式 JavaScript 前端开发
java中的static关键字
欢迎来到瑞雨溪的博客,博主是一名热爱JavaScript和Vue的大一学生,致力于全栈开发。如果你从我的文章中受益,欢迎关注我,将持续分享更多优质内容。你的支持是我前进的动力!🎉🎉🎉
53 8
|
1月前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
48 4
|
1月前
|
小程序 前端开发 算法
|
2月前
|
算法 Java 测试技术
🧑‍💻Java零基础:Java 的循环退出语句 break
【10月更文挑战第16天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
64 6