java循环（重点）

最新推荐文章于 2024-09-05 22:50:16 发布
最新推荐文章于 2024-09-05 22:50:16 发布
阅读量502 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67241922/article/details/126190714
版权

三目运算符语法格式：数据类型  变量名 = （表达式）条件1？：条件2

可以有多个表达式。

执行流程：表达式结果为true，则执行条件1，表达式为false，则执行条件2。

public class Demo4 {
    public static void main(String[] args) {
      int a = 30;
      int c;
     if (a > 0) {
         c=30;
         System.out.println(c);
     } else {
         c=23;
         System.out.println(c);
     }
    }
}
public class Demo4 {
    public static void main(String[] args) {
     int a = 23;
     String s1 = (a > 0)?"这个整数大于0":(a < 0)?"这个整数小于0":"这个整数等于0";
     System.out.println(s1);

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

     int b = -1;
     if (b > 0) {
         System.out.println("这个整数大于0");
     } else if (b < 0){
         System.out.println("这个整数小于0");
     } else {
         System.out.println("这个整数等于0");
     }
    }
}

循环结构（重点）

生活中的循环：摩天轮就是循环一圈一圈的转。

                         马拉松的跑道是循环，一圈一圈的

                         风扇也是循环

java代码中的循环：也是一圈一圈的执行，如果为false的则停止

循环结构三个条件：初始化的条件   循环条件   终止条件

while(表达式){

语句体；

++；循环条件；

}执行流程：首先走到while关键字  判断括号里的表达式为true，则执行语句体，++，之后在返回while关键字判断表达式结果为true，则执行当前括号中的语句体，++，再次返回while关键字结果为false则循环结束，不再执行语句体。

public class Demo4 {
    public static void main(String[] args) {
     /*
     a1 =23 走到while关键字
     23 < 30 结果为true，则执行语句体  a1++
     24 < 30 true 则执行语句体 a1++
     25 < 30 true 执行语句体  a1++；
     26 < 30 true 执行语句体 a1++
     27 < 30 true 执行语句体 a1++
     28 < 30 true 则执行语句体  a1++
     29 < 30 true 执行语句体  a1++
     30 < 30 false 循环结束不再执行语句体。        
      */
     int a1 = 23;//初始化的条件
     while (a1 < 30) {//循环的终止条件
         System.out.println(a1+"你好呀");
         a1++;//循环条件
     }
        System.out.println("嘻嘻哒");
    }
}


public class Demo4 {
    public static void main(String[] args) {
     /*
     a=1 1<=5 true 执行语句体1 a++
     a=2 2<=5 true 执行语句体2 a++    
     a=3 3<=5 true 执行语句体3 a++
     a=4 4<=5 true 则执行语句体4 a++
     a=5 5<=5 true 则执行语句体5 a++
     a=6 6<=5 false 则循环结束不在执行   
      */
     int a = 1;
     while (a <= 5) {
         System.out.println(a);
         a++;
     }
        System.out.println("哈哈大");
    }
}

public class Demo4 {
    public static void main(String[] args) {
    /*
    a1=100 100>=97 true 则执行语句体100 a1--
    a1=99  99>=97 true 则执行语句体99 a1--
    a1=98 98>=97 true 则执行语句体98 a1--
    a1=97 97>=97 true 则执行语句体97 a1--
    a1=96 96>=97 false 则循环结束不再执行当前的语句体
     */
    int a1 = 100;
    while (a1 >= 97){
        System.out.println(a1);
        a1--;
    }
        System.out.println("嘻嘻哒");
    }
}
public class Demo4 {
    public static void main(String[] args) {
      /*
      现有1-10位的数
      a1=1 1<=10 true 则进入if
      1%2==1 true 则输出语句体1  a1++
      a1=2 2<=10 2%2==1 false a1++
      a1=3 3<=10 true 3%2==1  true 则输出语句3 a1++
      a1=4 4<=10 true 4%2==1 false a1++
      a1=5 5<=10 true 5%2==1 true 则输出语句5 a1++
      a1=6 6<=10 true 6%2==1 false a1++
      a1=7 7<=10 true 7%2==1 true 则输出语句7 a1++
      a1=8 8<=10 true 8%2==1 false  a1++
      a1=9 9<=10 true 9%2==1 true 则输出语句9 a1++
      a1=10 10<=10 true 10%2==1 false a1++
      a1=11 11<=10 false 则循环结束
       */
      int a1 = 1;
      while (a1 <= 10) {
          if (a1 % 2 == 1) {
              System.out.println(a1);
          }
          a1++;
      }
    }
}
public class Demo4 {
    public static void main(String[] args) {
        /*
        a1=1 1<=10 true 输出语句1 1+=2
        a1=3 3<=10 true 输出语句3 1+=2
        a1=5 5<=10 true 输出语句5 1+=2
        a1=7 7<=10 true 输出语句7 7+=2
        a1=9 9<=10 true 输出语句9 9+=2;
        a1=11 11<=10 false 则不输出语句
         */
      int a1= 1;
      while(a1 <=10){
          System.out.println(a1);
          a1+=2;
      }
    }
}
public class Demo4 {
    public static void main(String[] args) {
   /*
   a1=1 1<=100 true 1%7==0 false a1++
   a1=2 2<=100 true 2%7==0 false a1++
   a1=3 3<=100 true 3%7==0 false a1++
   a1=4 4<=100 true 4%7==0 false a1++
   a1=5 5<=7 true 5%7==0 false a1++
   a1=6 6<=100 true 6%7==0 false  a1++
   a1=7 7<=100 true 7%7==0 true 则输出语句7 a1++
   a1=8 8<=100 true 8%7==0 false a1++
   a1=9 9<=100 treu 9%7==0 false a1++
   a1=10 10<=100 treu 10%7==0 fale a1++
   a1=11 11<=100 true 11%7==0 false a1++
   a1=12 12<=100 true 12%7==0 false a1++
   a1=13 13<=100 true 13%7==0 false a1++  
   a1=14 14<=100 true 14%7==0 true 组输出语句14 a1++   
   以此类推
    */
   int a1 = 1;
   while(a1 <= 100){
       if (a1 % 7 == 0){
           System.out.println(a1);
       }
        a1++;
        }
    }
}

do-while循环几乎不用

do{

语句体；

}while(表达式);

执行流程：首先走到do关键字，执行一次语句体，之后走到while关键字，判断括号里的表达式位true，则再次返回do则执行语句体，之后在到while关键字判断表达式为true，则到do打括号里执行语句体，再次判断while(括号里的结果为false)则循环结束。不再执行。

public class Demo4 {
    public static void main(String[] args) {
        /*
        a=1 执行语句体一次晚上加班 a++  1<=10 
        a=2 执行第二个语句体晚上加班 a++ 2<=10
        a=3 执行第三个语句体晚上加班 a++ 3<=10
        a=4 执行第四给语句体晚上加班 a++ 4<=10
        a=5 执行第五个语句体晚上加班 a++ 5<=10 
        a=6 执行第六个语句体晚上加班 a++ 6<=10
        以此类推
         */
        int a = 1;
        do{
           System.out.println(a+"晚上加班");
           a++;
        }while(a <= 10);
    }
}

重点：while循环和do while循环的区别

while循环：先判断  在执行

do=while:先执行一次语句体  在判断

for循环（重点）

循环的三个条件：初始化的条件  终止条件  循环条件

for循环语法格式：for（表达式1；表达式2；表达示3）{

                              循环体；

                              }

表达式1：初始化的条件 

表达示2：终止条件

表达示3：循环条件

执行流程：首先走到for关键字，先执行表达式1，在判断表达式2，结果为true，则执行语句体，在执行表达式3，之后在走到for关键字执行表达示1，在判断表达式2，结果为true则执行语句体，在执行表达式3，再次走到for关键字先执行表达式1，在次判断表达式结果为false，则循环结束。

public class Demo4 {
    public static void main(String[] args) {
      /*
      a=1 1<=3 true 则执行语句体云想衣裳花想容  a++
      a=2 2<=3 true 则执行语句体云想衣裳花想容  a++
      a=3 3<=3 true 则执行语句体云想衣裳花想容  a++
      a=4 4<=3 false 则循环结束
       */
      for(int a = 1; a<=3;a++){
          System.out.println("云想衣裳花想容");
       }
      //案例1：打印1-10以内的奇数
      /*
      a1=1 1<=10 则进入if判断
      1%2==1 true 则执行语句体1  a1++
      a1=2 2<=10 则进入if判断
      2%2==1 false a1++
      a1=3 3<=10 true 则进入if判断
      3%2==1 true 则输出语句3 a1++
      a1=4 4<=10 true 则进入if判断
      4%2==1 false a1++
      a1=5 5<=10 true 则进入if判断
      5%2==1 true 则执行语句体5  a1++
      a1=6 6<=10 true 则进入if判断
      6%2==1 false a1++
      a1=7 7<=10 true 则进入ifp判断
      7%2==1 true 则执行语句7 a1++
      a1=8 8<=10 true 则进入if判断
      8%2==1 false a1++
      a1=9 9 <=10 true 则进入if判断
      9%2==1 true 则执行语句体9  a1++
      a1=10 10<=10 true 则进入if判断
      10%2==1 false 则循环结束
       */
      for(int a1 = 1; a1<=10; a1++){
          if (a1 % 2 == 1){
              System.out.println(a1);
          }
      }
    }
}
public class Demo4 {
    public static void main(String[] args) {
        /*
        a=0 a<=100 true 则执行语句体0 a+=2
        a=2 2<=100 true 则执行语句体2 a+=2
        a=4 4<=100 true 则执行语句体4 a+=2
        a=6 7<=100 true 则执行语句体6 a+=2
        a=8 8<=100 true 则执行语句体8 a+=2
        a=10 10<=100true 则执行语句体10 a+=2
        a=12 12<=100 true 则执行语句体12 a+=2'
        a=14 14<=100 true 则执行语句体14 a+=2
        a=16 16<=100 true 则执行语句体16 a+=2
        a=18 18<=100 true 则执行语句体18 a+=2
        a=20 20<=100 true 则执行语句体20 a+=2
        a=22 22<=100 true 则执行语句体22 a+=2
        a=24 24<=100 true 则执行语句体24 a+=2
        以下也是这样执行
         */
        //打印100以内的偶数
        for(int a = 0; a<=100;a+=2){
            System.out.println(a);
        }
        //dayin100以内的奇数
        for(int a1 = 1; a1<=100;a1+=2){
            System.out.println(a1);
        }
    }
}
public class Demo4 {
    public static void main(String[] args) {
        //100以内的逢7过  凡是7的倍数和带7 的都要给我打印"过"   其他都是打印数字
        for (int a = 1; a<= 100;a++) {
            if (a % 7 == 0 || a /10 == 7 || a % 10 == 0){
                System.out.println("过");
            }else {
                System.out.println(a);
            }
        }
    }
}
public class Demo4 {
    public static void main(String[] args) {
        //0<=100 true j+=i  0+=0  i++
        //1<=100 true 0+=1 i++
        //2<=100 true 0+=1+2 i++
        //3<=100true 0+=1+2+3  i++
        //以此类推到99
        //99<=100 true 0=1+2+3+4+5+6+7+8...+99   i++
        //100<=100 true 0=0+1+2+3+4+5+6+7+8+9+10...+100
        //求1-100数的和
        int j = 0;
        for (int i = 0; i<=100; i++) {
            j+=i;
        }
        System.out.println(j);
    }
}

循环的嵌套

一个循环里面还有一个内层循环

秉承着一点内层循环结束之后，在回到外层循环执行。

 


public class Demo4 {
    public static void main(String[] args) {
        //*****
        //*****
        //*****
        /*
        i=1 1<=3 true 进入内层循环  
        i1=1 1<=4 true 则打印一颗星* i++
        i=2  2<=4 true 则打印两颗星星** i1++
        i1=3 3<=4 true 则打印三颗星星*** i1++
        i1=4 4<=4 true 则打印四颗星**** i1++
        i1=5 5<=4 false 则循环结束  换行 i++
        i=2 2<=3 true 则进入内层循环
        i1=1 1<=4 true 打印一颗星* i1++
        i1=2 2<=4 true 打印两颗行** i1++
        i1=3 3<=4 true 打印三颗星*** i1++
        i1=4 4《=4 true 打印四颗星星**** i1++
        i1=5 5<=4 false 则内层循环结束  i++
        以此类推
         */
        for (int i = 1; i<=3; i++) {
            for(int i1 = 1; i1<=4;i1++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印*

       ***

       *****

       ******* 

public class Demo4{
    public static void main(String[] args) {
        /*
        *
        ***
        *****
        *******  判断四行  没有空格
         */
        /*
        i=1 1<=4 true 进入内层循环
        j=1 1<=1 true 打印一颗星* j++
        j=2 2<=1 false 循环结束  i++
        i=2 2<=4 true 进入内层循环
        j=1 1<=3 true 打印一颗星* j++
        j=2 2<=3 true 打印两颗星** j++
        j=3 3<=3 true 打印三颗星*** j++
        j=4 4<=3 false 则循环结束  i++
        i=3 3<=4 true 则进入内层循环 
        j=1 1<=5 true 打印一颗星* j++
        j=2 2<=5 true 打印两颗星** j++
        j=3 3<=5 true 打印三颗星*** j++
        j=4 4<=5 true 打印四颗星**** j++
        j=5 5<=5 true 打印五颗星***** j++
        j=6 6<=5 false 则循环结束   以此类推 
         */
        for (int i = 1; i<=4;i++) {
          for(int j = 1; j<=2*i-1;j++){
              System.out.print("*");
           }
            System.out.println();//换行
        }
    }
}

打印99乘法表

public class Demo4{
    public static void main(String[] args) {
        //打印99乘法表
        for (int i = 1; i<=9; i++){
            for(int j = 1; j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

作业：替换两个数中的值。 

public class Demo4{
    public static void main(String[] args) {
        int a1 = 90;
        int a2 = 45;
        if (a1 > a2){
            int a3;
            a3=a1;
            a1=a2;
            a2=a3;
            System.out.println("a1="+a1);
            System.out.println("a2="+a2);
        } else {
            System.out.println("a1="+a1);
            System.out.println("a2="+a2);
        }
    }
}

小韩的快乐源泉
关注
java中的循环
m0_60438688的博客
07-23 8033
java中的循环详解+练习 简单易懂，三分钟掌握java循环
java枚举类循环_（转载）java 枚举 循环遍历以及一些简单常见的使用
weixin_42207707的博客
02-17 3172
本文转载自：http://blog.csdn.net/qq_27093465/article/details/51706076 作者：李学凯什么时候想用枚举类型：有时候，在设计一个java model对象的时候，你需要一些具体的常量字符串之类的东西，这个东西又没必要跟整个项目的全局常量放在一起，就放在model的java文件里面是最合适的，那么，你可以有两种选择：1，在java model文件里面...
循环结构
kkalllove的博客
11-08 119
Java 循环结构 - while, do…while 及 for 顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。 Java中有三种主要的循环结构： while 循环 do…while 循环 for 循环 continue继续 break终止 while 循环 结构为： while( 布尔表达式 ) { //循环内容 } 只要布尔表达式为 true，循环就会...
java(九)中的循环结构
最新发布
技术博客
09-05 440
我们在执行循环时，需要满足一定的循环条，反复执行特定的代码，当条件被打破时就要结束循环。第二步：执行循环条件，看判断条件满不满足，如果满足条件，执行循环体中的的语句，如果当条件不满足，就退出for循环；或者，当我们在循环中已经完成了本次循环的主要任务，就可以用continue语句提前结束本次循环，节省时间。例如，当我们在循环中遇到了某些无效的数据，就可以用continue语句跳过本次循环，继续处理下一个数据。例如，当我们在循环中找到了想要的结果，就可以用break语句结束循环，避免不必要的计算。
Java循环的三种方式
热门推荐
龙哥不管事的博客
08-06 1万+
一、 while循环 语法： while（循环条件）{ 循环体； } while循环先判断循环条件，如果条件成立，则执行循环体，循环完成后再判断一次循环条件，若成立，则继续执行循环体，直到循环条件不成立。 例如： int i = 1; while (i < 5) { ...
Java循环
ting2267的博客
04-18 1162
循环结构 – for, while及do…while 顺序结构的程序语句只能被执行一次。如果你想要同样的操作执行多次，就需要使用循环结构。 Java中有三种主要的循环结构： while循环 do…while循环 for循环 在Java5中引入了一种主要用于数组的增强型for循环。 while循环 while是最基本的循环，它的结构为： 格式： 只要布尔表达为true, 循环体会一直执行下去。 ...
java中for循环删除集合陷阱
09-03
这个问题主要出现在增强for循环（也称为foreach循环）和常规for循环中，但这里我们将重点讨论常规for循环。 增强for循环的语法如下： ```java for (Type item : collection) { // 循环体 } ``` 在这种情况下，Java...
Java循环跳转语句之continue共2页.pdf.zi
10-30
本知识点将重点讨论Java中的`continue`语句，它是循环控制的关键部分。 `continue`语句在Java中的作用是结束当前循环迭代，直接跳到循环体的下一个迭代。这意味着，当`continue`被执行时，所有位于它之后的代码将...
用java基础知识、循环、双重循环、随机数实现幸运抽奖功能。
03-16
幸运抽奖是项目的重点部分，需要用到Java的随机数生成。我们可以创建一个包含所有参与者ID的列表，然后使用Random类生成一个随机索引，对应列表中的一个ID。这样就可以确定“中奖者”。为了增加趣味性，可以设定多种...
Java的循环
qq_64960245的博客
06-28 3240
2）do-while循环是先执行一次循环操作，然后判断循环条件，所以如果第一次循环条件就不成立，那么循环操作也会执行一次（do-while循环循环操作至少会执行一次）2）判断循环条件，如果循环条件为true，执行循环操作代码，执行完循环操作代码，执行迭代代码，然后再去判断循环条件，根据循环条件决定是否执行循环操作代码。2）执行循环操作代码和迭代代码，然后去判断循环条件，如果循环条件为true，则继续执行循环操作代码和迭代代码，再判断循环条件。3）如果第一次判断循环条件不满足，那么循环操作一次都不会执行。
Java（循环）
weixin_71393275的博客
08-03 365
条件表达式 结果是true/false 如果条件为真则执行循环代码块。java循环分为三个，for 循环、whilt循环、do whilt循环。声明循环变量 ：本质是声明变量 ，一般声明循环变量的时候，都是重0开始。不管循环判断条件成立不，do里面的代码至少要执行一次。1.一个小案例利用for（输出1~100）的数字。2.利用for循环写1~100之间所有偶数的和。先判断在循环，通常会是无限循环。}while（循环判断）;while（循环判断）{先执行一次循环，在判断。流程和for循环是类似。
JAVA循环
antong2的博客
07-26 195
对于while循环语句而言，如果不满足条件，则不能进入循环，但有时候我们需要即使不满足条件，至少也要执行一次。dowhile和while类似但不相同，dowhile即使在不满足条件的去情况下至少会执行一次。while循环的布尔表达式如果为true则会进行死循环，正常的业务中应当避免出现死循环现象。while是先判断后执行，dowhile是先执行后判断。思考题计算1+2+3+.........+100=？dowhile总是保证循环体至少被执行一次。while循环是最基本的循环它的结构为。......
java-循环
toomemetoo的博客
01-02 75
三种循环 while循环 do-while循环 for循环 while循环 //while语法 while(boolean结果){ //如果boolean结果为真，进入循环里面 //为假，都不会进入循环体 } int j ; //定义变量 j = 1 ; while(j == 1) { //j为1时，进入循环体内 System.out.println(j); } while(true)死循环 什么时候会用到死循环呢，就是不知道终止条件，不知道什么时候结束，比如说玩猜
Java 循环
卢大宝宝的博客
05-31 85
Java中有三种主要的循环结构： while循环 do…while循环 for循环
Java 之循环
一直努力
07-12 927
Java 之循环 一、while循环 1.基本语法 while(循环条件) { 循环操作语句; } 2.while循环案例 2.1 使用循环计算1-100的累加和 package com.company; import java.util.Scanner; public class Main{ public static void main(String[] args){ int sum=0; int i=1; while(i
java 循环
牧小七的博客
06-04 796
do-while 循环与 while 循环类似，但它会先执行循环体，然后再检查循环条件。因此，循环体至少会执行一次。Java 提供了多种循环结构，可以用于重复执行一段代码。for 循环用于已知循环次数的情况下。它由三个部分组成：初始化表达式、循环条件和循环迭代。增强的 for 循环用于遍历数组或集合中的元素，它简化了对数组或集合的遍历操作。这些循环结构可以根据具体的需求选择适合的循环类型，使得代码能够有效地重复执行。while 循环用于在给定条件为真时重复执行一段代码。
Java循环语句教程及实例解析
由于描述信息重复，无法提供更多的细节，但可以确定的是，文档中涉及的内容重点是Java循环语句的知识点。 Java循环语句是Java编程语言中的核心概念之一，它允许程序执行重复的任务直到满足某个条件为止。Java提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值