Java語法基礎（四）----循環結構語句

一、循環結構：

循環語句可以在滿足循環條件的情況下，反復執行某一段代碼，這段被重復執行的代碼被稱為循環體語句，當反復執行這個循環體時，需要在合適的時候把循環判斷條件修改為false，從而結束循環，否則循環將一直執行下去，形成死循環。

循環語句的組成：

• 初始化語句：一條或者多條語句，這些語句完成一些初始化操作。
• 判斷條件語句：這是一個boolean 表達式，這個表達式能決定是否執行循環體。
• 循環體語句：這個部分是循環體語句，也就是我們要多次做的事情。
• 控制條件語句：這個部分在一次循環體結束后，下一次循環判斷條件執行前執行。通過用於控制循環條件中的變量，使得循環在合適的時候結束。

eg：在控制台輸出10次"HelloWorld"時，

• 初始化語句：定義初始化為第一次。
• 判斷條件語句：次數不能超過10次。
• 循環體語句：輸出”HelloWorld”語句。
• 控制條件語句：次數變化為下一次。

 

二、循環結構(for循環語句)

for循環語句格式：

for(初始化語句;判斷條件語句;控制條件語句) {
         循環體語句;
    }

執行流程：

A:執行初始化語句

B:執行判斷條件語句，看其結果是true還是false：如果是false，循環結束；如果是true，繼續執行。

C:執行循環體語句

D:執行控制條件語句

E:回到B繼續

流程圖：

注意事項：

（1）判斷條件語句的結果是一個boolean類型

（2）循環體語句如果是一條語句，大括號可以省略；如果是多條語句，大括號不能省略。建議永遠不要省略。

（3）一般來說：有左大括號就沒有分號，有分號就沒有左大括號

 

代碼舉例：

1、求出1-100之間偶數和：

/*
    需求：
        A:求1-100之和。
        B:求出1-100之間偶數和
*/
class ForTest1 {
    public static void main(String[] args) {
        //求1-100之和。
        int sum1 = 0;
        
        for(int x=1; x<=100; x++) {
            sum1 +=x;
        }
        
        System.out.println("1-100之和是："+sum1);
        System.out.println("------------------");
        
        //求出1-100之間偶數和
        //方式1
        int sum2 = 0;
        
        for(int x=1; x<=100; x++) {
            if(x%2 == 0) {
                sum2 += x;
            }
        }
        
        System.out.println("1-100偶數之和是："+sum2);
        System.out.println("------------------");
        
        //方式2
        int sum3 = 0;
        
        for(int x=0; x<=100; x+=2) {
                sum3 += x;
        }
        
        System.out.println("1-100偶數之和是："+sum3);
        System.out.println("------------------");
    }
}

2、求5的階乘：

/*
    需求：求5的階乘。
    
    什么是階乘呢?
        n! = n*(n-1)! 規則
        n! = n*(n-1)*(n-2)*...*3*2*1
        
    求和思想。
    求階乘思想。
*/
class ForTest2 {
    public static void main(String[] args) {
        //定義最終結果變量
        int jc = 1;
        
        //這里的x其實可以直接從2開始
        //for(int x=1; x<=5; x++) 
        
        for(int x=2; x<=5; x++) {
            jc *=x;
        }
        
        System.out.println("1-5的階乘是："+jc);
    }
}

3、在控制台輸出所有的“水仙花數”：

/*

    需求：在控制台輸出所有的”水仙花數”
    
    分析：
        我們都不知道什么叫"水仙花數"，你讓我怎么做呢?
        
        所謂的水仙花數是指一個三位數，其各位數字的立方和等於該數本身。
        舉例：153就是一個水仙花數。
        153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

        A:三位數其實是告訴了我們范圍。
        B:通過for循環我們就可以實現獲取每一個三位數
          但是麻煩是如何獲取這個三位數的個,十,百位上的數據
          
          我們如何獲取一個數據的個,十,百呢?
            假設有個一個數據:153
            ge:    153%10 = 3
            shi: 153/10%10 = 5
            bai：153/10/10%10 = 1
            qian：x/10/10/10%10
            wan:  x/10/10/10/10%10
            ...

        C:讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數據比較
          如果相同，就把該數據在控制台輸出。
*/
class ForTest3 {
    public static void main(String[] args) {
        //三位數其實是告訴了我們范圍。
        for(int x=100; x<1000; x++) {
            int ge = x%10;
            int shi = x/10%10;
            int bai = x/10/10%10;
            
            //讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數據比較
            if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                //如果相同，就把該數據在控制台輸出。
                System.out.println(x);
            }
        }
    }
} 

 

三、循環結構(while循環語句)

while循環語句格式：

   while(判斷條件語句) {
         循環體語句;
   }

   //擴展格式
   初始化語句;
   while(判斷條件語句) {
         循環體語句;
         控制條件語句;
    }

流程圖：

for循環和while循環的區別：

for循環語句和while循環語句可以等價轉換，但還是有些小區別的。

（1）使用區別：

控制條件語句所控制的那個變量，在for循環結束后，就不能再被訪問到了，而while循環結束還可以繼續使用，如果你想繼續使用，就用while，否則推薦使用for。原因是for循環結束，該變量就從內存中消失，能夠提高內存的使用效率。

（2）場景區別：

• for循環適合針對一個范圍判斷進行操作
• while循環適合判斷次數不明確操作

代碼舉例：

我國最高山峰是珠穆朗瑪峰：8848m，我現在有一張足夠大的紙張，厚度為：0.01m。請問，我折疊多少次，就可以保證厚度不低於珠穆朗瑪峰的高度?

/*
    我國最高山峰是珠穆朗瑪峰：8848m，我現在有一張足夠大的紙張，厚度為：0.01m。
    請問，我折疊多少次，就可以保證厚度不低於珠穆朗瑪峰的高度?

    分析：
        A:定義一個統計變量，默認值是0
        B:最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
          我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
        C:我折疊多少次，就可以保證厚度不低於珠穆朗瑪峰的高度?
          折疊一次有什么變化呢?就是厚度是以前的2倍。
        D:只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++
        E:輸出統計變量。
*/

class WhileTest01 {
    public static void main(String[] args) {
        //定義一個統計變量，默認值是0
        int count = 0;
        
        //最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
        //我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
        //為了簡單，我把0.01變成1，同理8848就變成了884800
        int end = 884800;
        int start = 1;
        
        while(start<end) {
            //只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++
            count++;
            
            //折疊一次有什么變化呢?就是厚度是以前的2倍。
            start *= 2;
            
            System.out.println("第"+count+"次厚度是"+start);
        }
        
        //輸出統計變量。
        System.out.println("要疊"+count+"次");
    }
}

 

四、循環結構(do…while循環語句)

基本格式：

   do {
         循環體語句;
   }while((判斷條件語句);

擴展格式：

   初始化語句;
   do {
         循環體語句;
         控制條件語句;
    } while((判斷條件語句);

流程圖：

 

五、循環結構的區別及注意事項：

三種循環語句其實都可以完成一樣的功能，也就是說可以等價轉換，但還是有小區別的:

• do…while循環至少會執行一次循環體。
• for循環和while循環只有在條件成立的時候才會去執行循環體

1、注意事項：

寫程序優先考慮for循環，再考慮while循環，最后考慮do…while循環。

如下代碼是死循環：

• while(true){}
• for(;;){}

2、循環的嵌套使用：就是循環語句的循環體本身是一個循環語句

（1）題目一：請輸出一個4行5列的星星(*)圖案：

提示：外循環控制行數，內循環控制列數

/*
    需求：請輸出下列的形狀
        *
        **
        ***
        ****
        *****

        提示：外循環控制行數，內循環控制列數
*/
class ForForTest01 {
    public static void main(String[] args) {
        //通過簡單的觀察，我們看到這是一個行是5，列數是變化的形狀
        //我們先打印出一個5行5列的形狀
        for(int x=0; x<5; x++) {
            for(int y=0; y<5; y++) {
                System.out.print("*");
            }
            System.out.println();
        }
        
        System.out.println("--------------");
        
        //我們實現了一個5行5列的形狀
        //但是這不是我們想要的
        //我們要的是列數變化的
        //列數是如何變化的呢?
        //第一行：1列    y=0,y<=0,y++
        //第二行：2列    y=0,y<=1,y++
        //第三行：3列    y=0,y<=2,y++
        //第四行：4列    y=0,y<=3,y++
        //第五行：5列    y=0,y<=4,y++
        //在看外循環x的變化，恰好就是x=0,1,2,3,4
        //所以這個最終版的程序就是如下
        for(int x=0; x<5; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

（2）題目二：在控制台輸出九九乘法表：

/*
    需求：在控制台輸出九九乘法表。
    
    首先我們寫出九九乘法表：
        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*9=9    2*9=18    3*9=27    ...
        
    我們先把這個九九乘法表看出是這樣的一個形狀：
        *
        **
        ***
        ****
        *****
        ******
        *******
        ********
        *********
        
    注意：
        '\x' x表示任意，這種做法叫轉移字符。
        
        '\t'    一個制表符的位置（tabtab鍵）
        '\r'    回車
        '\n'    換行
*/
class ForForTest02 {
    public static void main(String[] args) {
        for(int x=0; x<9; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("--------------");
        //為了使用數據，我們從1開始
        for(int x=1; x<=9; x++) {
            for(int y=1; y<=x; y++) {
                System.out.print(y+"*"+x+"="+y*x+"\t");
            }
            System.out.println();
        }
    }
}

運行效果：

 

六、跳轉控制語句：

前面我們已經說過了，Java中的goto是保留字，目前不能使用。雖然沒有goto語句可以增強程序的安全性，但是也帶來很多不便，比如說，我想在某個循環知道到某一步的時候就結束，現在就做不了這件事情。為了彌補這個缺陷，Java就提供了break，continue和return來實現控制語句的跳轉和中斷。

• break 中斷
  
• continue 繼續
  
• return 返回

 

1、跳轉控制語句(break)：

break的使用場景：

• 在選擇結構switch語句中
• 在循環語句中（循環語句中加入了if判斷的情況）

注：離開使用場景的存在是沒有意義的

break的作用：

A:跳出單層循環

B:跳出多層循環

         要想實現這個效果，就必須知道一個東西。帶標簽的語句。標簽名要符合Java的命名規則

         格式：

               標簽名: 語句

代碼舉例：

/*
    控制跳轉語句：
        break:中斷
        continue:繼續
        return:返回
    
    break:中斷的意思
    使用場景：
        A:switch語句中
        B:循環語句中。
            (循環語句中加入了if判斷的情況)
        注意：離開上面的兩個場景，無意義。
        
    如何使用呢?
        A:跳出單層循環
        B:跳出多層循環
            要想實現這個效果，就必須知道一個東西。帶標簽的語句。
            格式：
                標簽名: 語句
*/
class BreakDemo {
    public static void main(String[] args) {
        //在 switch 或 loop 外部中斷
        //break;
        
        //跳出單層循環
        for(int x=0; x<10; x++) {
            if(x == 3) {
                break;
            }
            System.out.println("HelloWorld");
        }
        
        System.out.println("over");
        System.out.println("-------------");
        
        //跳出多層循環
        wc:for(int x=0; x<3; x++) {
            nc:for(int y=0; y<4; y++) {
                if(y == 2) {
                    //break nc;
                    break wc;
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

第38行，我們給外面的循環加了一個標簽叫wc，然后在第42行跳轉出這個標簽。

運行效果：

注：實際開發中，幾乎用不到跳轉多層循環這個功能。

 

2、跳轉控制語句(continue)：

continue的使用場景：

• 在循環語句中
• 離開使用場景的存在是沒有意義的

continue和break的區別：

• break  跳出單層循環
• continue  跳出一次循環，進入下一次的執行。

效果如下：

面試題：

    for(int x=1; x<=10; x++) {
        if(x%3==0) {
            //在此處填寫代碼

        }
        System.out.println("Java學習");
    }

在上面代碼的第4行填入一行代碼，滿足一下條件：

• 我想在控制台輸出2次:"Java學習"            break;
• 我想在控制台輸出7次:"Java學習"            continue;
• 我想在控制台輸出13次:"Java學習"            System.out.println("Java學習");

 

3、跳轉控制語句(return)

return關鍵字不是為了跳轉出循環體，更常用的功能是結束一個方法，也就是退出一個方法，跳轉到上層調用的方法。

說白了：return的作用不是結束循環，而是結束方法。

效果如下：

 

循環語句結合break的練習：

面試題：小芳的媽媽每天給她2.5元錢，她都會存起來，但是，每當這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，請問，經過多少天，小芳才可以存到100元錢。

代碼實現：

/*
    需求：小芳的媽媽每天給她2.5元錢，她都會存起來，但是，
          每當這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，
          請問，經過多少天，小芳才可以存到100元錢。

    分析：
        A:小芳的媽媽每天給她2.5元錢
            double dayMoney = 2.5;
        B:她都會存起來
            double daySum = 0;
        C:從第一天開始存儲
            int dayCount = 1;
        D:經過多少天，小芳才可以存到100元錢。
            double result = 100;
        E:這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，
            說明要判斷dayCount的值，如果對5整除就減去6元錢。
                daySum -= 6;
          由此還隱含了一個問題，就是如果不是5的倍數天的話，錢要累加
                daySum += dayMoney;
        F:因為不知道是多少天，所以我用死循環，一旦超過100元我就退出循環。
*/
class WhileDemo {
    public static void main(String[] args) {
        //每天要存儲的錢是2.5元
        double dayMoney = 2.5;
        
        //存錢的初始化值是0
        double daySum = 0;
        
        //從第一天開始存儲
        int dayCount = 1;
        
        //最終存儲不小於100就不存儲了
        int result = 100;
        
        //因為不知道是多少天，所以我用死循環，
        while(true) {
            //累加錢
            daySum += dayMoney;
            
            //一旦超過100元我就退出循環。
            if(daySum >= result) {
                System.out.println("共花了"+dayCount+"天存儲了100元");
                break;
            }
            
            if(dayCount%5 == 0) {
                //花去6元錢
                daySum -= 6;
                System.out.println("第"+dayCount+"天花了6元錢");
            }
            
            //天數變化
            dayCount++;
        }
    }
}

 

 


我的公眾號

想學習代碼之外的軟技能？不妨關注我的微信公眾號：生命團隊（id：vitateam）。

掃一掃，你將發現另一個全新的世界，而這將是一場美麗的意外：