JAVA基础day04：循环结构for、while、do-while

程序流程控制

循环结构

• 在某些条件满足的情况下，反复执行特定代码。
• 循环语句的四个组成部分：
  • ① 初始化条件
  • ② 循环条件
  • ③ 循环体
  • ④ 迭代条件

三种循环

• for循环
• while循环
• do-while循环(较少使用)

for循环结构

for(①;②;④){
    ③
}
执行过程：①--》②-③-④--》②-③-④--》－－－》直到②不满足条件

代码实例

用for循环输出５行“hello”

class ForTest {
    public static void main (String[] args) {

        for(int i = 1;i <= 5; i++){　//i在for循环内有效
      //for(初始化条件；循环条件；迭代条件)
            System.out.println("hello");//循环体
        }
        //**********输出５行hello************

        //拓展
        int j = 1;
        for(System.out.print('a');j <= 2;System.out.print('c'),j++){
            System.out.print("b");
        }
        //输出abcbc
    }
}

遍历50以内的偶数，输出偶数的个数，并求所有偶数和

class ForTest1 {
    public static void main (String[] args) {

        int count = 0; //记录偶数个数
        int sum = 0; //记录求和

        for(int i = 1;i <= 50; i++){
            if(i % 2 == 0){
                System.out.println(i);
                count++;
                sum += i;
            } 
        }
        System.out.println("50以内偶数个数为：" + count);
        System.out.println("50以内偶数求和为：" + sum);
    }
}

---

while循环结构

之前提到的循环语句的四个组成部分：

• ① 初始化条件
• ② 循环条件
• ③ 循环体
• ④ 迭代条件

①
while(②){
    ③;
    ④;
}
执行过程：①--》②-③-④--》②-③-④--》－－－》直到②为false

代码实例

遍历50以内的偶数

class WhileTest {
    public static void main (String[] args) {

        int i = 1;//①初始化
        while(i <= 50){
            //②循环条件

            if(i % 2 == 0){           //
                System.out.println(i);//③循环体
            }                         //

            i++; //④迭代条件
        }
    }
}

• 注意：while循环不要丢了④迭代条件，可能死循环。
• for循环和while循环可互相转换

---

do-while循环结构

①
do{
    ③;
    ④;
}while(②)
执行过程：①--》③-④-②--》③-④-②--》－－－》直到②为false

• do-while循环，至少会执行一次循环体

代码实例

遍历50以内的偶数

class DoWhile {
    public static void main (String[] args) {

        int i = 1;//①初始化
        do{
            if(i % 2 == 0){           //
                System.out.println(i);//③循环体
            }                         //

            i++; //④迭代条件
        }while(i <= 50); //②循环条件
    }
}

补充：

• “无限”循环格式：for(;;)或while(true); 即，不在制循环条件部分限制次数的结构
• 跳出“无限”循环：在循环体中执行 break 语句，或在循环条件部分返回 false

代码实例

题目：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为０时结束程序。

import java.util.Scanner;

class ForWhileTest {
    public static void main (String[] args) {

        Scanner scan = new Scanner(System.in);

        int zhengshu = 0;//记录正数个数
        int fushu = 0;   //记录负数个数

        while(true){ //for(;;){
            int num = scan.nextInt();//先接受一个整数
            
            if(num > 0){      //判断，大于０则zhengshu自增１
                zhengshu++;    
            }else if(num < 0){//判断，小于０则fushu自增１
                fushu++;      
            }else{
                break;//执行break跳出循环
            }
        }
        System.out.println("输入的正数的个数为：" + zhengshu);
        System.out.println("输入的负数的个数为：" + fushu);
    }
}

---

嵌套循环

• 将一个循环结构Ａ声明在另一个循环结构体中，就构成了嵌套循环
• 分为：外层循环、内层循环
  • 内层循环结构 遍历 一遍，只相当于外层循环体执行 一次
  • 若外层循环执行m次，内层循环执行n次，此时内层循环的 循环体 一共执行了m*n次

代码实例

输出：

          i(行号)    j(*的个数)
*               1          1
**             2          2
***           3          3
****         4          4
*****       5          5

class ForFor {
    public static void main (String[] args) {

        for(int i = 1;i <= 5;i++){ //控制行数
            for(int j = 1;j <= i;j++){　//控制列数
                System.out.print("*");
            }
            System.out.println();
        } 
    }
}

输出：

          i(行号)    j(*的个数) 
*****       1          5
****         2          4      规律：i+j=6，即：j=6-i
***           3          3
**             4          2
*               5          1

class ForFor {
    public static void main (String[] args) {

        for(int i = 1;i <= 5;i++){ //控制行数
            for(int j = 1;j <= 6-i;j++){　//控制列数
                System.out.print("*");
            }
            System.out.println();
        } 
    }
}

打印９＊９乘法表：

1*1 = 1  
2*1 = 2  2*2 = 4  
3*1 = 3  3*2 = 6  3*3 = 9  
    .       .       .
    .       .       .
9*1 = 9  9*2 = 18  ...  9*8 = 72  9*9 = 81

class NineNineTable {
    public static void main (String[] args) {

        for(int i = 1;i<= 9;i++){
            for(int j = 1;j <= i;j++){
                System.out.print(i + "*" + j + " = " + (i * j) + "  ");
            }
            System.out.println();
        }
    }
}

输出100以内所有的质数（面试可能出现）

质数：只能背１和其本身整除的数。

• –>假设这个数为 n ，则从２开始，到 n-1为止，都不能被这个数本身整除。
• 最小的质数是２

class ZhiShu {
    public static void main (String[] args) {

        boolean isFlag = true;//标识，看i是否被j除尽,　除尽则变更其值

        for(int i = 2;i <= 100;i++){//遍历2～100

            for(int j = 2;j <= i - 1;j++){//遍历２～i之间的数
                if(i % j == 0){//i被j除尽，则j是i的约数
                    isFlag = false;
                    break;//只要有一个被除尽，则后面的就不用算了，不是质数，直接跳出循环
                }
            }
            if(isFlag == true){
                System.out.println(i);
            }
            //重置isFlag值
            isFlag = true;
        }
    }
}

特殊关键字：break 和 continue

• break:
  • 使用范围：switch-case结构、循环结构
  • 作用：结束 当前 循环
• continue:
  • 使用范围：循环结构
  • 作用：结束 当次 循环
• break和continue语句后面不能声明执行语句

代码实例

class BreakContinue {
    public static void main (String[] args) {

        for(int i = 1;i <= 10;i++){
            if(i % 4 == 0){

                //break;//输出123，遇到４终止循环

                continue;//输出1235678910，遇到４结束当次循环，继续下一次循环
                //continue;后的语句无法编译和执行。

                //System.out.print(i);//加上该语句编译报错
            }
            System.out.print(i);
        }
    }
}

跳出指定循环层

• break跳出的是包裹此关键字最近的一层循环
  • 但，可结束指定标签的循环层！

代码实例

class BreakContinue1 {
    public static void main (String[] args) {

        flag1:for(int i = 1;i <= 4;i++){

            for(int j = 1;j <= 10;j++){
                if(j % 4 == 0){

                    //break;//默认跳出最近一层循环结构
                    //

                    break flag1;//结束指定标签的一层循环结构
                    //continue flag1;//结束指定标签一层循环结构的当次循环
                }
                System.out.print(j);
            }
            
        }
    }
}

输出结果

break flag1;
输出：123

break;
输出：123123123123

下一篇：JAVA基础day05: 数组（声明、调用、复制、Arrays工具类）

JAVA基础day05: 数组（声明、调用、复制、Arrays工具类）