循环结构

本文主要是介绍循环结构，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

循环结构

• while循环

  • while是最基本的循环，它的结构为：

  while（布尔表达式）{

  //循环内容

  }

  • 只要布尔表达式为true，循环就会一直执行下去。

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

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

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

  • 思考：计算1+2+3.....+100=？

    package com.tang.struct;
    ​
    public class WhileDemo01 {
        public static void main(String[] args) {
            //输出1--100
            int i = 0;
            while (i<100) {
                ;
                i++;
                System.out.println(i);
            }
    ​
        }
    }
    //while (ture){  为死循环 尽量避免！
    ​
    ​
    =================================================================
       package com.tang.struct;
    ​
    public class whileDemo02 {
        public static void main(String[] args) {
            //计算1+2+3+....+100=？
            int i =0;
            int sum =0;
            while (i<=100){
                sum =sum +i;
                i++;
                System.out.println(sum);
            }
        }
    }
    

• do...while循环

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

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

    do{

    //代码语句

    }while（布尔表达式）；

  • while和do...while的区别：

    1. while先判断后执行。do...while是先执行后判断！

    2. do...while总是保证循环体会被至少执行一次！这是最大的区别。

  package com.tang.struct;//示例
  ​
  public class DoWhileDemo03 {
      public static void main(String[] args) {
          int i =0;
          int sum =0;
          do {
              sum = sum + i;
              i++;
          } while (i <=100);
              System.out.println(sum);
  ​
      }
  }
  ================================================================
      package com.tang.struct;//区别
  ​
  public class DoWhileDemo04 {
      public static void main(String[] args) {
          int a =0;
          while (a<0){
              a++;
          }
          //上面的没有执行
          System.out.println("===========================================");
          do {
              System.out.println(a);//输出0
              a++;
          }while (a<0);
      }
  }
  ​

• for循环

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

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

  • for循环执行的次数是在执行前就确定的。语法格式如下：

  for（初始化；布尔表达式；更新）{

  //代码语句

  }

  package com.tang.struct;
  ​
  public class ForDemo01 {
      public static void main(String[] args) {
          int a = 1;//初始化条件
          while (a<=100){//条件判断
              System.out.println(a);//循环体
              a+=2;//迭代  (a=a+2)
  ​
          }
          System.out.println("while循环结束！");
          //初始化//条件判断//迭代
          for (int i =1;i<=100;i++){    //快捷键  ：  100.for
              System.out.println(i);
  ​
          }
          System.out.println("for循环结束！");
          /*
          关于for循环有一下几点说明：
          最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
          然后，检测布尔表达式的值。如果为true，循环被执行。如果为false。循环终止，开始执行循环后面的语句。
          再次检测布尔表达式。循环执行上面的过程。
           */
          //死循环
          for (; ; ){
          }
      }
  }

  • 练习1：计算0-100之间的奇数和偶数的和

  package com.tang.struct;
  ​
  public class ForDemo02 {
      public static void main(String[] args) {
          //练习1：计算0--100之间的奇数和偶数的和
          //奇数和
          int oddSum = 0;
          //偶数和
          int evenSum = 0;
          for (int i = 0; i <= 100; i++) {
              if (i%2 !=0){    //奇数
                  oddSum+=i;  //oddSum = oddSum + i
              }else {          //偶数
                  evenSum+=i;
              }
              
          }
          System.out.println("奇数的和"+oddSum);
          System.out.println("偶数的和"+evenSum);
  ​
      }
  }

  • 练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

  package com.tang.struct;
  ​
  public class ForDemo03 {
      public static void main(String[] args) {
          //练习2：用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 输出完会换行
          //println 输出完不会换行
      }
  }

  • 练习3：打印九九乘法表

  package com.tang.struct;
  /*
  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 ForDemo04 {
      public static void main(String[] args) {
          //1.先打印第一列，
          //2.把固定的1 再用一个循环抱起来
          //3.去掉重复的项，i<=j
          //4.调整样式
          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();
  ​
  ​
  ​
  ​
          }
  ​
      }
  }

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

  • 这里我们只是先见一面做个了解，之后数组我们重点使用

  • Java5引用了一种主要用于数组或集合的增强型for循环

  • Java增强for循环语法格式如下：

  for（声明语句：表达式）

  {

  //代码句子

  }

  • 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句快，其值与此时数组元素的值相等。

  • 表达式：表达式是要访问的数组名，或者是返回的值为数组方法。

  package com.tang.struct;
  ​
  public class ForDemo05 {
      public static void main(String[] args) {
          int[] numbers ={10,20,30,40,50};//定义了一个数组
          //遍历数组的元素
          for (int x:numbers){//增强for
              System.out.println(x);
  ​
              System.out.println("===================");
              for (int i = 0; i < 5; i++) {  //基础for
                  System.out.println(numbers[i]);
  ​
              }
  ​
          }
      }
  }

   

•  

这篇关于循环结构的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！