java Day07-1

循环结构

  1. while循环

    • while 是基础的循环

      while(布尔表达式){

      //循环内容

      }

    • 只有布尔表达式为ture,循环就会一直执行下去

    • 我们大多数情况是会让循环停下来的,我们需要一个让表达式失效的方式来结束循环

    • 少部分情况需要循环一直执行,比如服务器的请求响应监听等

    • 循环条件一直为ture就会造成无限循环【死循环】,我们正常编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃

      • 案例

        复制代码
        package com.wei.struct;
        
        public class WhileDemo01 {
            public static void main(String[] args) {
        
        
                //输出1-10
        
                int i = 1;
                while (i < 10){
                    i++;
                    System.out.println(i);
                }
            }
        }
      • 结果

        1

        2

        3

        4

        5

        6

        7

        8

        9

        10

    • 思考计算:1+2+3+4+5+...+100=?

      • 案例

        复制代码
        package com.wei.struct;
        
        public class WhileDemo03 {
            public static void main(String[] args) {
                //计算1+2+3+4+5+...+100=?
        
                //
        
                int i = 0;
                int sum = 0;
        
                while (i<=100){
                    sum = sum + i;
                    i++;
                }
                System.out.println(sum);
            }
        }
      • 结果

        5050

  2. do .....while 循环

    • 对于while语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次

    • do...while循环和while循环相似,不同的是,do...while循环至少会执行一次

      do{

      ​ //代码语句

      }while(布尔表达式);

    • While和do...while的区别

      • while先判断后执行,dowhile实现执行后判断

      • do...while总是保证循环体会被至少执行一次!(主要区别)

      • 案例1

        复制代码
        package com.wei.struct;
        
        public class DoWhileDemo01 {
            public static void main(String[] args) {
                int i = 0;
                int sum = 0;
        
                do {
                    sum = sum + i;
                    i++;
                }while (i<=100);
                System.out.println(sum);
            }
        }
      • 结果1

        5050

      • 案例2

        复制代码
        package com.wei.struct;
        
        public class DoWhileDemo02 {
            public static void main(String[] args) {
                int a =0;
                while (a<0){
                    System.out.println(a);
                    a++;
                }
                System.out.println("*****************");
                do {
                    System.out.println(a);
                    a++;
                }while(a<0);
            }
        }
      • 结果2


        0

  3. for 循环

    • 虽然所有循环结构都可以用while或者do...while表示,但Java提供了另一种语句------for、循环,使一些循环结构变得更加简单

    • for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构

    • for循环执行的次数是在执行前就确定的

      for(初始值;布尔表达式;更新){

      //代码语句

      }

      • 案例1

        复制代码
        package com.wei.struct;
        
        public class ForDemo01 {
            public static void main(String[] args) {
                int a = 0; //初始化条件
        
                while (a<10){ //条件判断
                    System.out.println(a);  //循环体
                    a+=1;  //迭代
                }
        
                System.out.println("while循环结束!");
        
                //初始值//条件判断//迭代
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
        
                System.out.println("for循环结束!");
            }
        }
      • 结果1

        0

        1

        2

        3

        4

        5

        6

        7

        8

        9

        while循环结束!

        0

        1

        2

        3

        4

        5

        6

        7

        8

        9

        for循环结束!

      • 案例:计算0到100之间的技术和偶数之和

        复制代码
        package com.wei.struct;
        
        public class ForDemo02 {
            public static void main(String[] args) {
        
                //计算0到100之间的技术和偶数之和
        
                int oddsum = 0 ;
                int evensum = 0 ;
        
                for (int i = 0; i < 100; i++) {
                    if (i%2!=0) {
                        oddsum+=i;
                    }else {
                        evensum+=i;
                    }
                }
                System.out.println("奇数的和"+oddsum);
                System.out.println("偶数的和"+evensum);
            }
        
        }
      • 结果

        奇数的和2500

        偶数的和2450

      • 案例:用while或for语句循环输出1-1000之间能被5整除的数,并且每行输出3个

        复制代码
        package com.wei.struct;
        
        public class ForDemo03 {
            public static void main(String[] args) {
                //用while或for语句循环输出1-1000之间能被5整除的数,并且每行输出3个
                for (int i = 0; i<=1000; i++) {
                    if (i%5==0) {
                        System.out.print(i+"\t");
                    }
                    if (i%(5*3)==0){ //每行
                        System.out.println();
                        //System.out.println("\n");
                    }
                }
        
                //println  输出完全换行
                //print  输出完全不换行
                
            }
        }
      • 结果

        0

        5 10 15

        20 25 30

        35 40 45

        50 55 60

        65 70 75

        80 85 90

        95 100 105

        110 115 120

        125 130 135

        140 145 150

        155 160 165

        170 175 180

        185 190 195

        200 205 210

        215 220 225

        230 235 240

        245 250 255

        260 265 270

        275 280 285

        290 295 300

        305 310 315

        320 325 330

        335 340 345

        350 355 360

        365 370 375

        380 385 390

        395 400 405

        410 415 420

        425 430 435

        440 445 450

        455 460 465

        470 475 480

        485 490 495

        500 505 510

        515 520 525

        530 535 540

        545 550 555

        560 565 570

        575 580 585

        590 595 600

        605 610 615

        620 625 630

        635 640 645

        650 655 660

        665 670 675

        680 685 690

        695 700 705

        710 715 720

        725 730 735

        740 745 750

        755 760 765

        770 775 780

        785 790 795

        800 805 810

        815 820 825

        830 835 840

        845 850 855

        860 865 870

        875 880 885

        890 895 900

        905 910 915

        920 925 930

        935 940 945

        950 955 960

        965 970 975

        980 985 990

        995 1000

      • 案例:九九乘法表

        复制代码
        package com.wei.struct;
        
        public class ForDemo04 {
            public static void main(String[] args) {
                //1.先打印第一列
                //2.固定的1再用一个循环包起来
                //3.去掉重复项,i<=j
                //调整样式
        
                for (int j = 1; j <=9; j++) {
                    for (int i = 1; i <=j; i++) {
                    System.out.print(j+"*"+i+"="+(j*i) + "\t");
                    }
                    System.out.println();
                }
            }
        }
      • 结果

        11=1
        2
        1=2 22=4
        3
        1=3 32=6 3 3=9

        41=4 4 2=8 43=12 4 4=16

        51=5 5 2=10 53=15 5 4=20 55=25
        6
        1=6 62=12 6 3=18 64=24 6 5=30 66=36
        7
        1=7 72=14 7 3=21 74=28 7 5=35 76=42 7 7=49

        81=8 8 2=16 83=24 8 4=32 85=40 8 6=48 87=56 8 8=64

        91=9 9 2=18 93=27 9 4=36 95=45 9 6=54 97=63 98=72 9*9=81

  4. 在Java5中引入了一种主要用于数组的增强型for循环