Java学习day5程序控制流程二

循环结构：

　　循环语句的四个组成部分：1.初始化部分（init_statement）

　　　　　　　　　　　　　　2.循环条件部分（test_exp）

　　　　　　　　　　　　　　3.循环体部分（body_statement）

　　　　　　　　　　　　　　4.迭代部分（after_statement）

一、for循环

　　　　for循环执行的次数是在执行前就确定的，语法如下：

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

　　　　for循环执行说明：

　　　　　　　　1.最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。

　　　　　　　　2.然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。

　　　　　　　　3.执行一次循环后，更新循环控制变量。

　　　　　　　　4.再次检测布尔表达式。循环执行上面的过程。

　　　　实例：

//从1循环到150并打印出每一个值，另外在每个3的倍数上打印出“fo”，在每个5的倍数上打印出“foo”，
//在每个7的倍数上打印出“fooo”，在每个9的倍数上打印出“foooo”
public class Circulation {
    public static void main(String args[]){
        for(int i = 1;i <= 150;i++){//1~150的循环
            String str = "";//str变量初始化为空字符串
            str += i;//str=i+1，把i拼接到字符串上，再考虑i是否是3、5、7、11的倍数
            if(i % 3 == 0){//不用if...else是因为要判断i是否同时为3、5、7、11的倍数，比如105fofoofooo
                str += "fo";
            }
            if(i % 5 == 0){
                str += "foo";
            }
            if(i % 7 == 0){
                str += "fooo";
            }
            if(i % 11 == 0){
                str += "foooo";
            }
            System.out.println(str);
        }
            
    }
}

输出结果：

 

实例2：输出所有的水仙花数（水仙花数是指一个3位数，其各个位数上的数字立方和等于其本身，例如153=1*1*1+5*5*5+3*3*3）

public class Circulation2 {
    public static void main(String args[]){
        for(int i = 100; i <= 999; i++){
            //153=100+50+3
            int m = i/100;//得到百位数的值
            int n = (i - m*100)/10;//得到十位数的值
            int p = i - m*100 - n*10;//得到个位数的值
            //System.out.println(i);
            //System.out.println(m + " " + n + " " + p + " ");//输出检验是否将153拆分为1 5 3
            int res =  m*m*m + n*n*n + p*p*p;//求各个位上数字的立方和
            if(res == i){//判断是不是水仙花数
                System.out.println(i);
            }
        }
    }
}

打印结果为：

 

 二、while循环和do...while循环

　　　　1.while循环，表达式为：

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

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

实例：求1到100之间所有偶数的和

public class Circulation3 {
    public static void main(String args[]){
        int res = 0;
        int i = 1;
        while(i <= 100){
            if(i % 2 ==0){
                res += i;
            }
            i++;
        }
        System.out.println(res);
    }
}

打印结果为：2550

 

　　　　2.do...while循环，表达式为：

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

　　　　1.对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。do…while 循环和 while 循环相似，但两者不同的是，    do…w hile循环至少会执行一次。

　　　　2.对于do...while语句，布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

　　　　3.补充：最简单的无限循环格式为 while(true) 和 for(;;)。无限循环存在的原因在于不知道循环多少次，需要根据某些条件来控制循环。

 

实例：循环输出1~100的值和每次循环相加的和。

public class Circulation4 {
    public static void main(String args[]){
        int res = 0;
        int i = 1;
        do{
            res += i;
            System.out.println(i +" " + res);
            i++;
        }while(i <= 100);
    }
}

打印结果：

 

 

三、嵌套循环

　　　　1.将一个循环放在另一个循环体内，就形成了嵌套循环，for、while、do...while均可以作为外层循环和内层循环。

　　　　2.实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始外层的下一次循环。

　　　　3.设外层的循环次数是m次，内层的循环次数是n次，则内层循环体实际上需要执行m*n次。

.　　　　4.注意：在写嵌套循环的时候，要尽量保证外层的循环次数小于内层的循环次数

 

实例：打印九九乘法表

public class Circulation5 {
    public static void main(String args[]){
        for(int i = 1; i <= 9; i++){//i作为大循环，需要循环九次；
            for(int j = 1; j <= i; j++){//j作为小循环，受大循环的限制，例如i=2时，j需要做2次循环(j=1时和j=2时，都满足j<=i)
                System.out.print(i + " * " + j + " = " + (i * j) + "  ");//print不换行
            }
            System.out.println();// println换行打印
        }
    }
}

打印结果：

 

实例2：输出1~100之间的所有质数（质数是指一个只能被1和它本身整除的大于1的自然数）

public class Circulation6 {
    public static void main(String args[]){
        for(int i = 1; i <= 100; i++){//首先，要循环1~100之间的所有数
            int k = 0;//定义一个变量k并初始化为0作为整除的次数，变量只在它所在的大括号范围之内生效
            
            for(int j = 1; j <=i; j++){
                if(i % j ==0){//循环1~i,并用i对1~i之间的数j分别取模
                    k++;//若j能被i整除，则整除的次数k加一
                }
            }
            if(k == 2){//质数只能被1和它本身整除，所以k=2
                System.out.println(i);//输出质数
            }
        }
    }
}

打印结果为：

 

四、特殊流程控制语句：break关键字、continue关键字和return关键字

　　　　1.break关键字：1.break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

　　　　　　　　　　　 2.break 终止当前所在的循环，并且继续执行该循环下面的语句。

实例：

public class Circulation7 {
    public static void main(String args[]){
        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 999; j++){
            if(j > 2){
                break;//当j》2时，终止当前循环，但不影响外侧的大循环
            }
            System.out.println(j);
            }
        }
    }
}

打印结果：

 

　　　　2.continue关键字：

　　　　　　　　　　　　1.continue 适用于任何循环控制结构中。作用是对当前所在的循环起作用，结束当前这次循环，当前循环的下面的代码不执行，让程序立刻跳转到下一次循环的迭代（跳过某个循环块的一次执行）。

　　　　　　　　　　　　2.在 for 循环中，continue 语句使程序立即跳转到更新语句。

    　　　　　　　　　　　3.在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

　　　　　　　　　　　　4.continue语句出现在多层嵌套循环语句体中时，可以通过标签指明要跳过的是哪一层循环。

实例：

public class Circulation8 {
    public static void main(String args[]){
        for(int i = 0; i <= 9; i++){
            if(i % 2 == 0){
                continue;//符合条件时直接结束当前这次循环，不执行打印语句，直接进入下次循环
            }
            System.out.println(i);
        }
    }
}

打印结果：

 

 

　　　　3.return关键字

　　　　　　　　1.与break不同的是，break是结束一个循环，而return是结束一个函数

实例：

public class Circulation9 {
    public static void main(String args[]){
        for(int i = 0; i < 2; i++){
            for(int j = 0; j < 2; j++){
                if(j == 1){
                    //return;//没有输出结果
                    break;//输出结果为01
                }
            }
            System.out.print(i);
        }
    }
}

 　　　　特殊流程控制语句说明：

　　　　　　　　1.break只能用于switch语句和循环语句中。

　　　　　　　　2.continue只能用于循环语句中。

　　　　　　　　3.continue是终止本次循环，break是终止本层循环。

　　　　　　　　4.break、continue之后不能有其他语句，因为程序永远不会执行其后的语句。