Java流程控制語句最全彙總(中篇)

前文

本章是關於Java流程控制語句的最全彙總，本篇為彙總中篇。

流程是人們生活中不可或缺的一部分，它表示人們每天都在按照一定的流程做事。

比如出門搭車、上班、下班、搭車回家。這其中的步驟是有順序的。

程式設計也需要有流程控制語句來完成使用者的要求，根據使用者的輸入決定程式要進入什麼流程，即“做什麼”以及“怎麼做”等。

從結構化程式設計角度出發，程式有 3 種結構：順序結構、選擇結構和迴圈結構。

若是在程式中沒有給出特別的執行目標，系統則預設自上而下一行一行地執行該程式，這類程式的結構就稱為順序結構。

到目前為止，我們所編寫的程式都屬於順序結構。

但是事物的發展往往不會遵循早就設想好的軌跡進行，因此，所設計的程式還需要能夠具有在不同的條件下處理不同問題以及當需要進行一些相同的重複操作時，如何能省時省力地解決問題的能力。

在本章中，我們將對 Java 程式中的上述3種流程結構進行學習。

初學者應該對本章的每個小節進行仔細閱讀、思考，這樣才能達到事半功倍的效果。

Java switch case語句詳解

if…else 語句可以用來描述一個“二岔路口”，我們只能選擇其中一條路來繼續走，然而生活中經常會碰到“多岔路口”的情況。

switch 語句提供了 if 語句的一個變通形式，可以從多個語句塊中選擇其中的一個執行。

switch 語句格式

switch 語句是 Java 的多路分支語句。

它提供了一種基於一個表示式的值來使程式執行不同部分的簡單方法。

因此，它提供了一個比一系列 if-else-if 語句更好的選擇。

switch 語句的基本語法形式如下所示：

switch(表示式) {
    case 值1:
        語句塊1;
        break;
    case 值2:
        語句塊2;
        break;
    …
    case 值n:
        語句塊n;
        break;
    default:
        語句塊n+1;
    break;
}

其中，switch、case、default、break 都是 Java 的關鍵字。

switch

表示“開關”，這個開關就是 switch 關鍵字後面小括號裡的值，小括號裡要放一個整型變數或字元型變數。

表示式必須為 byte，short，int，char型別。

Java7 增強了 switch 語句的功能，允許 switch 語句的控制表示式是 java.lang.String 型別的變數或表示式。

只能是 java.lang.String 型別，不能是 StringBuffer 或 StringBuilder 這兩種字串的型別。

case

表示“情況，情形”，case 標籤可以是：

• 型別為 char、byte、 short 或 int 的常數表示式。
• 列舉常數。
• 從 Java SE 7 開始， case 標籤還可以是字串字面量。

例如：

String input = ...;
switch (input.toLowerCase()) {  // toLowerCase用於將大寫字元轉換為小寫
    case "yes":
        ...
        break;
}

當在 switch 語句中使用列舉常數時，不必在每個標籤中指明列舉名，可以由 switch 的表示式值確定。例如：

Size sz = ...;
switch (sz) {
    case SMALL: // no need to use Size.SMALL
        ...
        break;
    ...
}

注意：重複的 case 值是不允許的。

default

表示“預設”，即其他情況都不滿足。

default 後要緊跟冒號，default 塊和 case 塊的先後順序可以變動，不會影響程式執行結果。

通常，default 塊放在末尾，也可以省略不寫。

break

表示“停止”，即跳出當前結構。

如果在 case 分支語句的末尾沒有 break 語句，有可能觸發多個 case 分支。

那麼就會接著執行下一個 case 分支語句。這種情況相當危險，常常會引發錯誤。

為此，我們在程式中從不使用 switch 語句。

如果你喜歡 switch 語句，編譯程式碼時可以考慮加上 -Xlint:fallthrough 選項，如下所示：

javac -Xlint:fallthrough Test.java

這樣一來，如果某個分支最後缺少一個 break 語句，編譯器就會給出一個警告訊息。

switch 語句的執行過程如下：表示式的值與每個 case 語句中的常數作比較。

如果發現了一個與之相匹配的，則執行該 case 語句後的程式碼。

如果沒有一個 case 常數與表示式的值相匹配，則執行 default 語句。

當然，default 語句是可選的。如果沒有相匹配的 case 語句，也沒有 default 語句，則什麼也不執行。

圖 1 switch語句執行流程圖

例 1

在節目的抽獎環節裡，節目組會根據每位嘉賓的座位號來進行抽獎遊戲，根據不同的號碼來決定獎項的大小。

使用 switch 語句編寫 Java 程式來完成獎項分配，其實現程式碼如下。

public static void main(String[] args) {
    System.out.println("請輸入座位號碼：");
    Scanner sc = new Scanner(System.in);
    int num = sc.nextInt();
    switch (num) {
    case 8:
        System.out.println("恭喜你，獲得了三等獎！");
        break;
    case 88:
        System.out.println("恭喜你，獲得了二等獎！");
        break;
    case 888:
        System.out.println("恭喜你，獲得了一等獎！");
        break;
    default:
        System.out.println("謝謝參與！");
        break;
    }
}

當用戶輸入的號碼為 888 時，獲取的 num 值為 888，則與第三個 case 後的值匹配，執行它後面的語句，輸出“恭喜你，獲得了一等獎！”，然後執行 break 語句，跳出整個 switch 結構。如果輸入的號碼與 case 中的值都不匹配，則執行 default 後的語句。

程式執行結果如下所示：

請輸入座位號碼：
888
恭喜你，獲得了一等獎！
請輸入座位號碼：
88
恭喜你，獲得了二等獎！
請輸入座位號碼：
66
謝謝參與！

例 2

編寫一個 Java 程式，根據當前的星期數位輸出對應的漢字。在這裡使用包含 break 的 switch 語句來判斷當前的星期，實現程式碼如下：

public static void main(String[] args) {
    String weekDate = "";
    Calendar calendar = Calendar.getInstance();  // 獲取當前時間
    int week = calendar.get(Calendar.DAY_OF_WEEK) - 1;  // 獲取星期的第幾日
    switch (week) {
        case 0:
            weekDate = "星期日";
            break;
        case 1:
            weekDate = "星期一";
            break;
        case 2:
            weekDate = "星期二";
            break;
        case 3:
            weekDate = "星期三";
            break;
        case 4:
            weekDate = "星期四";
            break;
        case 5:
            weekDate = "星期五";
            break;
        case 6:
            weekDate = "星期六";
            break;
    }
    System.out.println("今天是 " + weekDate);
}

本程式首先獲取當前的星期值，然後使用 switch 語句判斷 week 的值：0 表示星期日，1 表示星期一，2 表示星期二……以此類推，6 表示星期六。只要 week 值與 case 值相符合，則程式將執行該 case 中的語句，並跳出 switch 語句，輸出結果。

執行程式，輸出的結果如下：

今天是星期五

巢狀 switch 語句

可以將一個 switch 語句作為一個外部 switch 語句的語句序列的一部分，這稱為巢狀 switch 語句。

因為一個 switch 語句定義了自己的塊，外部 switch 語句和內部 switch 語句的 case 常數不會產生衝突。

例如，下面的程式段是完全正確的：

public static void main(String[] args) {
    switch (count) {
        case 1:
            switch (target) {
            case 0:
                System.out.println("target is zero");
                break;
            case 1:
                System.out.println("target is one");
                break;
            }
            break;
        case 2: // ...
    }
}

本例中，內部 switch 語句中的 case 1 ：語句與外部 switch 語句中的 case 1 ：語句不衝突。

變數 count 僅與外層的 case 語句相比較。

如果變數 count 為 1，則變數 target 與內層的 case 語句相比較。

學到這裡我們可以發現以下幾點：

• switch 語句不同於 if 語句的是 switch 語句僅能測試相等的情況，而 if 語句可計算任何型別的布林表示式。也就是 switch 語句只能尋找 case 常數間某個值與表示式的值相匹配。
• 在同一個 switch 語句中沒有兩個相同的 case 常數。當然，外部 switch 語句中的 case 常數可以和內部 switch 語句中的 case 常數相同。
• switch 語句通常比一系列巢狀 if 語句更有效。

最後一點尤其有趣，因為它使我們知道 Java 編譯器如何工作。

當編譯一個 switch 語句時，Java 編譯器將檢查每個 case 常數並且創造一個“跳轉表”，這個表將用來在表示式值的基礎上選擇執行路徑。

因此，如果你需要在一組值中做出選擇，switch 語句將比與之等效的 if-else 語句快得多。

編譯器可以這樣做是因為它知道 case 常數都是同型別的，所要做的只是將它與 switch 表示式相比較看是否相等。

對於一系列的 if 表示式，編譯器就無此功能。

if 語句和 switch 語句的區別

if 和 switch 語句都表示條件語句，可以從使用效率和實用性兩方面加以區分。

1.從使用效率上區分

從使用效率上區分，在對同一個變數的不同值作條件判斷時，既可以使用 switch 語句，也可以使用 if 語句。

使用 switch 語句的效率更高一些，尤其是判斷的分支越多，越明顯。

2. 從實用性上區分

從語句的實用性角度區分，switch 語句不如 if 條件語句，if 語句是應用最廣泛和最實用的語句。

3. 何時使用 if 語句和 switch 語句

在程式開發的過程中，何時使用 if 語句和 switch 語句，需要根據實際情況而定，應儘量做到物盡其用。

不能因為 switch 語句的效率高就一直使用，也不能因為 if 語句常用就不用 switch 語句。

需要根據實際情況，具體問題具體分析，使用最適合的條件語句。

一般情況下，對於判斷條件較少的，可以使用 if 條件語句，但是在實現一些多條件的判斷中，最好使用 switch 語句。

Java while和do while迴圈詳解

迴圈是程式中的重要流程結構之一。

迴圈語句能夠使程式程式碼重複執行，適用於需要重複一段程式碼直到滿足特定條件為止的情況。

所有流行的程式語言中都有迴圈語句。

Java 中採用的迴圈語句與C語言中的迴圈語句相似，主要有 while、do-while 和 for。

另外 Java 5 之後推出了 for-each 迴圈語句，for-each 迴圈是 for 迴圈的變形，它是專門為集合遍歷而設計的。for-each 並不是一個關鍵字。

迴圈語句可以在滿足迴圈條件的情況下，反覆執行某一段程式碼，這段被重複執行的程式碼被稱為迴圈體。

當反覆執行這個迴圈體時，需要在合適的時候把迴圈條件改為假，從而結束迴圈，否則迴圈將一直執行下去，形成死迴圈。

迴圈語句可能包含如下 4 個部分。

• 初始化語句（init statement）： 一條或多條語句，這些語句用於完成一些初始化工作，初始化語句在迴圈開始之前執行。
• 迴圈條件（test_expression）：這是一個 boolean 表示式，這個表示式能決定是否執行迴圈體。
• 迴圈體（body_statement）：這個部分是迴圈的主體，如果迴圈條件允許，這個程式碼塊將被重複執行。如果這個程式碼塊只有一行語句，則這個程式碼塊的花括號是可以省略的。
• 迭代語句（iteration_statement）：這個部分在一次迴圈體執行結束後，對迴圈條件求值之前執行，通常用於控制迴圈條件中的變數，使得迴圈在合適的時候結束。

上面 4 個部分只是一般性的分類，並不是每個迴圈中都非常清晰地分出了這 4 個部分。

由於篇幅有限，本文主要介紹 while 和 do-while。

while 語句

while 語句是 Java 最基本的迴圈語句，是一種先判斷的迴圈結構，可以在一定條件下重複執行一段程式碼。

該語句需要判斷一個測試條件，如果該條件為真，則執行迴圈語句（迴圈語句可以是一條或多條），否則跳出迴圈。

while 迴圈語句的語法結構如下：

while(條件表示式) {
    語句塊;
}

其中語句塊中的程式碼可以是一條或者多條語句，而條件表示式是一個有效的 boolean 表示式，它決定了是否執行迴圈體。當條件表示式的值為 true 時，就執行大括號中的語句塊。

執行完畢，再次檢查表示式是否為 true，如果還為 true，則再次執行大括號中的程式碼，否則就跳出迴圈，執行 while 迴圈之後的程式碼。圖 1 表示了 while 迴圈語句的執行流程。

圖 1 while 迴圈語句執行流程圖

例 1

使用 while 語句計算 10 的階乘，其具體程式碼如下所示。

public static void main(String[] args) {
    int i = 1;
    int n = 1;
    while(i <= 10) {
        n=n*i;
        i++;
    }
    System.out.println("10的階乘結果為："+n);
}

在上述程式碼中，定義了兩個變數 i 和 n，迴圈每執行一次 i 值就加 1，判斷 i 的值是否小於等於 10，並利用 n=n*i 語句來實現階乘。當 i 的值大於 10 之後，迴圈便不再執行並退出迴圈。

執行程式，執行的結果如下所示：

10 的階乘結果為：3628800

do-while 語句

如你剛才所見，如果 while 迴圈一開始條件表示式就是假的，那麼迴圈體就根本不被執行

。然而，有時需要在開始時條件表示式即使是假的情況下，while 迴圈至少也要執行一次。

換句話說，有時你需要在一次迴圈結束後再測試中止表示式，而不是在迴圈開始時。

幸運的是，Java就提供了這樣的迴圈：do-while迴圈。

do-while 迴圈語句也是 Java 中運用廣泛的迴圈語句，它由迴圈條件和迴圈體組成，但它與 while 語句略有不同。

do-while 迴圈語句的特點是先執行迴圈體，然後判斷迴圈條件是否成立。

do-while 語句的語法格式如下：

do {
    語句塊;
}while(條件表示式);

以上語句的執行過程是，首先執行一次迴圈操作，然後再判斷 while 後面的條件表示式是否為 true，如果迴圈條件滿足，迴圈繼續執行，否則退出迴圈。

while 語句後必須以分號表示迴圈結束，其執行流程如圖 2 所示。

圖 2 do-while 迴圈語句的執行流程

例 2

編寫一個程式，計算 10 的階乘。使用 do-while 迴圈的實現程式碼如下所示。

public static void main(String[] args) {
    int number = 1,result = 1;
    do {
        result*=number;
        number++;
    }while(number <= 10);
    System.out.print("10階乘結果是："+result);
}

程式執行後輸出結果如下：

10 階乘結果是：3628800

例 3

在一個圖書系統的推薦圖書列表中儲存了 50 條資訊，現在需要讓它每行顯示 10 條，分 5 行進行顯示。下面使用 do-while 迴圈語句來實現這個效果，其具體程式碼如下所示。

public static void main(String[] args) {
    int bookIndex = 1;
    do {
        System.out.print(bookIndex+"t");
        if(bookIndex%10 == 0) {
            System.out.println();
        }
        bookIndex++;
    }while(bookIndex<51);
}

在上述程式碼中， 宣告一個變數 bookIndex 用來儲存圖書的索引，該變數賦值為 1 表示從第一本開始。

在 do-while 迴圈體內，首先輸出了 bookIndex 的值，然後判斷 bookIndex 是否能被 10 整除，如果可以則說明當前行已經輸出 10 條，用 System.out.println() 語句輸出了一個換行符。

之後使 bookIndex 加 1，相當於更新當前的索引。最後在 while 表示式中判斷是否超出迴圈的範圍，即 50 條以內。

執行程式，執行的結果如下所示。

1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50

while和do-while的比較

while 迴圈和 do-while 迴圈的相同處是：都是迴圈結構，使用 while(迴圈條件) 表示迴圈條件，使用大括號將回圈操作括起來。

while 迴圈和 do-while 迴圈的不同處如下：

• 語法不同：與 while 迴圈相比，do-while 迴圈將 while 關鍵字和迴圈條件放在後面，而且前面多了 do 關鍵字，後面多了一個分號。
• 執行次序不同：while 迴圈先判斷，再執行。do-while 迴圈先執行，再判斷。
• 一開始迴圈條件就不滿足的情況下，while 迴圈一次都不會執行，do-while 迴圈則不管什麼情況下都至少執行一次。

Java for迴圈詳解

for 語句是應用最廣泛、功能最強的一種迴圈語句。

大部分情況下，for 迴圈可以代替 while 迴圈、do while 迴圈。

for 語句是一種在程式執行前就要先判斷條件表示式是否為真的迴圈語句。

假如條件表示式的結果為假，那麼它的迴圈語句根本不會執行。

for 語句通常使用在知道迴圈次數的迴圈中。

for 語句語法格式如下所示。

for(條件表示式1;條件表示式2;條件表示式3) {
    語句塊;
}

for 關鍵字後面括號中的 3 個條件表示式必須用“;”隔開。

for 迴圈中的這 3 部分以及大括號中使迴圈體必需的 4 個組成部分完美地結合在一起，簡單明瞭。

for 迴圈語句執行的過程為：首先執行條件表示式 1 進行初始化，然後判斷條件表示式 2 的值是否為 true，如果為 true，則執行迴圈體語句塊；否則直接退出迴圈。最後執行表示式 3，改變回圈變數的值，至此完成一次迴圈。

接下來進行下一次迴圈，直到條件表示式 2 的值為 false，才結束迴圈，其執行流程如圖 1 所示。

圖 1 for迴圈執行流程圖

值得指出的是，for 迴圈的迴圈迭代語句並沒有與迴圈體放在一起，因此即使在執行迴圈體時遇到 continue 語句結束本次迴圈，迴圈迭代語句也一樣會得到執行。

for 迴圈和 while、do while 迴圈不一樣：

由於 while、do while 迴圈的迴圈迭代語句緊跟著迴圈體，因此如果迴圈體不能完全執行，如使用 continue 語句來結束本次迴圈，則迴圈迭代語句不會被執行。

但 for 迴圈的迴圈迭代語句並沒有與迴圈體放在一起，因此不管是否使用 continue 語句來結束本次迴圈，迴圈迭代語句一樣會獲得執行。

與前面迴圈類似的是，如果迴圈體只有一行語句，那麼迴圈體的大括號可以省略。

例如，同樣是計算 5 的階乘，使用 for 迴圈的實現程式碼如下：

public static void main(String[] args) {
    int result = 1;
    for (int number = 1; number <= 5; number++) {
        result *= number;
    }
    System.out.print("5 的階乘結果是：" + result);   // 輸出"5的階乘結果是：120"
}

上述語句的含義可以理解為，將 number 變數的值從 1 開始，每次遞增 1，直到大於 5 時終止迴圈。在迴圈過程中，將 number 的值與當前 result 的值進行相乘。

for 語句中初始化、迴圈條件以及迭代部分都可以為空語句（但分號不能省略），三者均為空的時候，相當於一個無限迴圈。下面對這些情況依次進行介紹。

條件表示式 1 為空

for 語句中條件表示式 1 的作用可以在程式的其他位置給出，所以當條件表示式 1 為空時，for 語句後面括號內其他條件表示式執行的順序不變。

例如，使用 for 語句的這種形式計算 1~100 所有奇數的和。

public static void main(String[] args) {
    int result = 0;
    int number = 1; // 相當於for語句的第1個表示式
    for (; number < 101; number++) {
        if (number % 2 != 0) // 如果不能整除2，說明是奇數，則進行累加
            result += number;
    }
    System.out.print("100 以內所有奇數和為：" + result);
}

執行後的輸出結果如下：

100 以內所有奇數和為：2500

條件表示式 2 為空

當 for 語句中條件表示式 2 為空時，將沒有迴圈的終止條件。

此時 for 語句會認為條件表示式 2 的值總是為真，迴圈無限制執行下去。因此，為了使迴圈達到某種條件時退出，需要在語句塊中進行邏輯判斷，並使用 break 語句來跳出迴圈，否則將產生死迴圈。

同樣是計算 1~100 所有奇數的和，使用這種方式的程式碼如下。

public static void main(String[] args) {
    int result = 0;
    for (int number = 1;; number++) {
        if (number > 100)
            break; // 相當於for語句的表示式2，滿足時就退出for迴圈
        if (number % 2 != 0) // 如果不能整除2，說明是奇數，則進行累加
            result += number;
    }
    System.out.print("100 以內所有奇數和為：" + result);
}

條件表示式 3 為空

當 for 語言中條件表示式 3 為空時，也就沒有設定控制變數的表示式，即每次迴圈之後無法改變變數的值，此時也無法保證迴圈正常結束。

同樣是計算1~100 所有奇數的和，使用這種方式的程式碼如下：

public static void main(String[] args) {
    int result = 0;
    for (int number = 1; number < 101;) {
        if (number % 2 != 0) // 如果不能整除2，說明是奇數，則進行累加
            result += number;
        number++; // 相當於for語句的條件表示式3，每次遞增1
    }
    System.out.print("100 以內所有奇數和為：" + result);
}

如果沒有迴圈體語句，number 變數的值為 1，永遠小於 101，因此將無法結束迴圈，形成無限迴圈。

在上面程式碼中將 number 的遞增語句放在 for 迴圈體內，效果與完整 for 語句功能相同。

3 個條件表示式都為空

在 for 迴圈語句中，無論缺少哪部分條件表示式，都可以在程式的其他位置補充，從而保持 for 迴圈語句的完整性，使迴圈正常進行。

當 for 語句中迴圈體全為空時，即沒有迴圈初值，不判斷迴圈條件，迴圈變數不增值，此時無條件執行迴圈體，形成無限迴圈或者死迴圈。

對於這種情況，讀者在使用時應該儘量避免。

例如，計算 1~100 所有奇數的和，使用這種方式的程式碼如下：

public static void main(String[] args) {
    int result = 0;
    int number = 1; // 相當於for語句的條件表示式1
    for (;;) {
        if (number > 100)
            break; // 相當於for語句的條件表示式2
        if (number % 2 != 0) // 如果不能整除2，說明是奇數，則進行累加
            result += number;
        number++; // 相當於for語句的條件表示式3
    }
    System.out.print("100 以內所有奇數和為： " + result);
}

例 1

編寫一個 Java 程式，統計某超市上半年的總銷售量，要求由使用者輸入每月的銷量。使用 for 迴圈的實現程式碼如下。

public static void main(String[] args) {
    int sum = 0;
    int num = 0;
    Scanner sc = new Scanner(System.in);
    for (int i = 1; i <= 6; i++) {
        System.out.println("請輸入第" + i + " 個月的銷售數量：");
        num = sc.nextInt();
        sum += num;
    }
    System.out.println("上半年的銷售總量為：" + sum);
}

在該程式中, 宣告迴圈變數 i，控制迴圈的次數，它被初始化為 1。

每執行一次迴圈，都要對 i 進行判斷，看其值是否小於等於 6，條件成立則繼續累加成績，否則退出迴圈。

每執行完一次迴圈體，都會對 i 累加 1。

如此迴圈重複，直到 i 的值大於 6 時停止迴圈。此時退出 for 迴圈體，執行最下方的語句輸出累加的銷售總量。

執行程式，執行結果如下所示。

請輸入第1 個月的銷售數量：
6840
請輸入第2 個月的銷售數量：
5449
請輸入第3 個月的銷售數量：
6546
請輸入第4 個月的銷售數量：
2400
請輸入第5 個月的銷售數量：
908
請輸入第6 個月的銷售數量：
8048
上半年的銷售總量為：30191

一般選擇迴圈變數時，習慣選擇 i、j、k 來作為迴圈變數。

for、do-while 和 while 的區別

例2

分別用 for、do-while 和 while 求出 1-10 的和。

使用for迴圈

程式碼如下：

public static void main(String[] args) {
    int sum = 0;
    for (int i = 1; i < 11; i++) {
        sum = sum + i;
    }
    System.out.println(sum);
}

執行結果為 55。

使用 do-while 迴圈

程式碼如下：

public static void main(String[] args) {
    int sum = 0;
    int i = 1;
    do {
        sum = sum + i;
        i++;
    } while (i < 11);
    System.out.println(sum);
}

執行結果為 55。

使用 while 迴圈

程式碼如下：

public static void main(String[] args) {
    int sum = 0;
    int i = 1;
    while (i < 11) {
        sum = sum + i;
        i++;
    }
    System.out.println(sum);
}

執行結果為 55。

從上邊程式碼可以看出 for 語句明顯更加簡練，因為知道迴圈次數。

到此這篇關於Java流程控制語句最全彙總(中篇)的文章就介紹到這了,其他兩個部分的內容(上、下篇)請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com!