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流程控制語句最全匯總(中篇)的文章就介紹到這瞭,其他兩個部分的內容(上、下篇)請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!