流程控制03 循环结构 打印九九乘法表

#1.循环结构

  * while循环
  * do...while循环
  * for循环


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

##（1）while循环

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

while(布尔表达式){
//循环内容
}

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

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

package com.tianyu.structure;

public class whileDemo02 {
    public static void main(String[] args) {
        while(true){
            //等待客户端连接
            //定时检查
            //.....
        }
    }
}

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

package com.tianyu.structure;

public class whileDemo02 {
    public static void main(String[] args) {
        while(true){
            //等待客户端连接
            //定时检查
            //.....
        }
    }
}

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

  * 思考：计算1+2+3+...+100=?

package com.tianyu.structure;

public class whileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+...+100
        int i = 0;
        int sum = 0;
        while (i<100) {
            i++;
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

(2)do while循环

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

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

do {
     //代码语句
}while(布尔表达式)；

    * while和do...while区别

          * while先判断后执行，dowhile是先执行后判断

          * do....while总是保证循环体会被至少执行一次！这是他们的主要差别

    * 示例

package com.tianyu.structure;

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);
    }
}

    * 示例：while和dowhile循环区别

package com.tianyu.structure;

public class whileDemo04 {
    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<1);
    }
}

/*输出结果：
==================================
0
 */

(3)for循环

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

package com.tianyu.structure;

public class forDemo01 {
    public static void main(String[] args) {
        int a =1;   //初始化条件

        while (a<100){   //条件判断
            System.out.println(a);    //循环体
            a+=2;
        }
        System.out.println("while循环结束！");


        //初始化//条件判断//迭代
        for (int i = 0; i < 100; i++) {      //100.for回车快捷输入
            System.out.println(i);
        }
        System.out.println("for循环结束！");
    }
}

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

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

for (初始化;布尔表达式;更新){
        //代码语句
}

    * 关于for循环有以下几点说明：

          * 最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
          * 然后，检测布尔表达式的值，如果为true，循环体被执行，如果为false，循环终止，开始执行循环体后面的语句
          * 执行一次循环后，更新循环控制变量（迭代银子控制循环变量的增减）
          * 再次检测布尔表达式，循环执行上面的过程
          * 死循环

for(; ; ){

}

    * print和println

        * print输出完不会换行
        * println输出完会换行

    * 练习1：计算0到100之间的奇数和偶数的和

package com.tianyu.structure;

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){                 //取余不为0是奇数，为0是偶数
                oddsum = oddsum + i;
            }else
                evensum = evensum + i;

        }
        System.out.println("奇数的和："+oddsum);
        System.out.println("偶数的和："+evensum);
    }
}

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

package com.tianyu.structure;

public class forDemo03 {
    public static void main(String[] args) {
        //用while或for循环输出1-1000之间能被5整除的数，并且每行输出三个
        
        //方法一
        for (int i = 0; i <= 1000; i++) {
            if (i%5==0){
                if (i%(5*3)==0){
                    System.out.println(i);
                }else{
                    System.out.print(i+"\t");
                }

            }

        }
        
        //方法二
        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  输出完不会换行
    }

  
}

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

package com.tianyu.structure;

public class forDemo04 {
    public static void main(String[] args) {
        //打印九九乘法表
        /* 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
        */

        for (int i = 1; i < 10; i++) {
            for (int i1 = 1; i1 <= i; i1++) {
                System.out.print(i1+"*"+i+"="+i*i1+"\t");
            }
            System.out.println();
        }
    }
}

(4)增强for循环

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

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

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

for(声明语句：表达式)
{
//代码句子
}

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

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

  * 示例

package com.tianyu.structure;

public class forDemo05 {
    public static void main(String[] args) {
        int[] numbers ={10,20,30,40,50};  //定义了一个数组

        for (int i = 0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("===============================");

        //遍历数组的元素
        for (int x:numbers){
            System.out.println(x);
        }


    }
}