[[401840]]

本文轉(zhuǎn)載自微信公眾號「蝸?；ヂ?lián)網(wǎng)」，作者蝸牛互聯(lián)網(wǎng)。轉(zhuǎn)載本文請聯(lián)系蝸?；ヂ?lián)網(wǎng)公眾號。

本文大綱：

為什么需要流程控制

平時我們做一件事，一般都會有個固定流程。

比如你想吃蘋果，你需要找到冰箱，打開冰箱門，取出蘋果，回到沙發(fā)上，然后開吃。

這個順序基本不能調(diào)換，你不能在打開冰箱門之前去取蘋果。按順序來控制，這是一種流程。

那如果你想吃香蕉，你會發(fā)現(xiàn)流程類似，只是從冰箱里取出香蕉就好了。

在這個過程里，你會發(fā)現(xiàn)你最終吃什么，取決于你的選擇。你要吃蘋果，你從冰箱里取蘋果，你要吃香蕉，你從冰箱里取香蕉。按選擇來控制，這也是一種流程。

那還有種情況，一根香蕉不夠你吃，你還想吃幾根，直到你不想吃，那你就會重復(fù)上面的流程，當(dāng)你吃飽的時候，就終止了。這種重復(fù)執(zhí)行按照某個條件來終止的控制，也是一種流程。

計算機(jī)是現(xiàn)實世界的電子化表達(dá)，那么在計算機(jī)的世界里，程序運行也需要這樣的流程控制。

無論是機(jī)器語言，還是匯編語言，還是高級程序設(shè)計語言，都會涉及這個概念，它決定了你寫的代碼會按照怎樣的路徑運行，也決定著計算機(jī)和用戶之間的交互方式。

我們看看 Java 語言的流程控制是什么樣的?

輸入和輸出

我們編程都是為了解決某個實際問題，比如寫一個加法程序，我們是為了獲得兩個數(shù)的和是多少。

那你會發(fā)現(xiàn)，程序有個重要的特點，就是接收輸入，然后進(jìn)行處理，最后輸出結(jié)果。

那 Java 是怎么接收輸入的呢?

Scanner 介紹

Java 提供了 Scanner 工具類，我們可以通過這個工具類來獲取用戶的輸入?；镜恼Z法如下：

// 用標(biāo)準(zhǔn)的輸入流構(gòu)建一個 Scanner 對象 
Scanner scanner = new Scanner(System.in); 
 
// 讀取輸入的一行并獲取字符串 
String nextLineStr = scanner.nextLine(); 
 
// 讀取輸入的字符串，會忽略掉字符串兩邊的空格，因為空格起分隔符或結(jié)束符的作用 
String nextStr = scanner.next(); 
 
// 讀取輸入的整數(shù)，非整數(shù)會拋異常(InputMismatchException) 
int nextInt = scanner.nextInt(); 

System.in 是標(biāo)準(zhǔn)的輸入流，使用它可以接收鍵盤輸入或其他指定數(shù)據(jù)源的數(shù)據(jù)。

Scanner 是一個簡單的文本掃描器，通過它可以解析基本類型和字符串。new Scanner(System.in) 可以構(gòu)建出一個掃描器對象，scanner.nextLine()可以讀取輸入的一行并獲取字符串，scanner.next() 也可以獲取字符串，不過不能支持兩邊有空格的字符串，scanner.nextInt() 可以讀取輸入的整數(shù)，int 換成其他基本類型同樣也適用。

Scanner 使用

我們可以看下樣例代碼：

package cn.java4u.flowcontrol; 
 
import java.util.Scanner; 
 
/** 
 * 輸入演示 
 * 
 * @author 蝸牛 
 * @from 公眾號：蝸牛互聯(lián)網(wǎng) 
 */ 
public class InputDemo { 
 
    public static void main(String[] args) { 
 
        // 用標(biāo)準(zhǔn)的輸入流構(gòu)建一個 Scanner 對象 
        Scanner scanner = new Scanner(System.in); 
 
        // 讀取輸入的一行并獲取字符串 
        String nextLineStr = scanner.nextLine(); 
 
        // 讀取輸入的字符串，會忽略掉字符串兩邊的空格，因為空格起分隔符或結(jié)束符的作用 
        String nextStr = scanner.next(); 
 
        // 讀取輸入的整數(shù)，非整數(shù)會拋異常(InputMismatchException) 
        int nextInt = scanner.nextInt(); 
 
        System.out.println("---以下為打印值---"); 
        System.out.println("nextLineStr:" + nextLineStr); 
        System.out.println("nextStr:" + nextStr); 
        System.out.println("nextInt:" + nextInt); 
 
    } 
} 

你會發(fā)現(xiàn)，樣例代碼里有一個 import java.util.Scanner; ，Scanner 是 Java 類庫里的一個類，所以需要 import 語法引入一下，才能使用。

樣例代碼有三次控制臺輸入，我們輸入以下數(shù)據(jù)看下輸出：

我是蝸牛    
   蝸牛666     
8 

第一行輸入的字符串后邊有空格，第二行輸入的字符串前后都有空格。輸出如下：

---以下為打印值---

---以下為打印值--- 
nextLineStr:我是蝸牛    
nextStr:蝸牛666 
nextInt:8 

你會發(fā)現(xiàn) nextLineStr 后邊的空格還在，nextStr 前后的空格都沒有了。

我們再看一種輸入：

我是蝸牛    
   蝸牛666  7 

當(dāng)我們輸入兩行后，再回車，程序就直接輸出結(jié)果了：

nextLineStr:我是蝸牛    
nextStr:蝸牛666 
nextInt:7 

由此可見 nextLine()和 next() 之間的不同，nextInt() 是 next() 基礎(chǔ)上的類型轉(zhuǎn)換，特點可以認(rèn)為和 next() 一致。

起始符 分隔符 特點 
nextLine()  任何字符    回車(Enter)   可以獲得帶空格的字符串 
next()  非空白字符   空格  不能獲得帶空格的字符串 

輸出

在之前的代碼中，我們都是通過 System.out.println() 的方式，把內(nèi)容輸出到控制臺的。

其中 System.out 是標(biāo)準(zhǔn)的輸出流，通過它不只可以做顯示輸出，也可以寫入到指定的輸出目標(biāo)，比如文件。

println 是 print line 的縮寫，表示輸出并換行。如果輸出不想換行，可以使用 print() 。此外，Java 也支持用 printf() 進(jìn)行格式化輸出，以方便閱讀。

以下是示例代碼：

package cn.java4u.flowcontrol; 
 
/** 
 * 輸出演示 
 * @author 蝸牛 
 * @from 公眾號：蝸牛互聯(lián)網(wǎng) 
 */ 
public class OutputDemo { 
 
    public static void main(String[] args) { 
 
        // 輸出并換行 
        System.out.println("---開始演示---"); 
        // 輸出不換行 
        System.out.print("打印不換行["); 
        System.out.print("1 "); 
        System.out.print("2 "); 
        System.out.print("3"); 
        System.out.print("]"); 
        // 只換行 
        System.out.println(); 
        // 格式化輸出 
        double d = 66600000.8888; 
        // 不進(jìn)行格式化的處理結(jié)果：6.66000008888E7 
        System.out.println("不進(jìn)行格式化的處理結(jié)果：" + d); 
        System.out.printf("默認(rèn)格式化：%f", d); 
        System.out.printf("; 無小數(shù)格式化：%.0f", d); 
        System.out.printf("; 一位小數(shù)格式化：%.1f", d); 
        System.out.printf("; 兩位小數(shù)格式化：%.2f", d); 
    } 
} 

輸出結(jié)果如下：

---開始演示--- 
打印不換行[1 2 3] 
不進(jìn)行格式化的處理結(jié)果：6.66000008888E7 
默認(rèn)格式化：66600000.888800; 無小數(shù)格式化：66600001; 一位小數(shù)格式化：66600000.9; 兩位小數(shù)格式化：66600000.89 

%f 就是 Java 為浮點數(shù)提供的格式化功能的占位符，系統(tǒng)默認(rèn)會把浮點數(shù)格式化成 6 位小數(shù)輸出，當(dāng)然你也可以仿照樣例指定小數(shù)位輸出。

除了浮點數(shù)，Java 的格式化功能還提供了多種占位符，可以把各種數(shù)據(jù)類型格式化成指定的字符串，以下是常用的占位符：

占位符	說明
%d	格式化輸出整數(shù)
%x	格式化輸出十六進(jìn)制整數(shù)
%f	格式化輸出浮點數(shù)
%e	格式化輸出科學(xué)計數(shù)法表示的浮點數(shù)
%s	格式化字符串

注意，由于 % 表示占位符，因此，連續(xù)兩個 %% 表示一個 % 字符本身。

三種流程控制結(jié)構(gòu)

知道了輸入和輸出在 Java 世界里的表達(dá)方式，我們再看下在程序處理中涉及到的流程控制有哪些。

順序結(jié)構(gòu)

程序基本的流程結(jié)構(gòu)就是順序結(jié)構(gòu)，Java 也是如此。如果沒有特別指明，程序都是按照順序一行一行執(zhí)行。

選擇結(jié)構(gòu)

但很多時候，我們需要判斷一個東西是否可行，然后才去執(zhí)行一段邏輯。比如加法程序，我們得要求參與運算的值是數(shù)字而不能是字符串。

那這樣的流程控制可以通過選擇結(jié)構(gòu)來實現(xiàn)。

if單選擇結(jié)構(gòu)

如果只是想針對某個條件特殊處理下，處理前后的邏輯不變，此時可以使用if單選擇結(jié)構(gòu)。

語法如下：

if(布爾表達(dá)式){ 
 //布爾表達(dá)式結(jié)果為 true 時執(zhí)行的語句 
} 

以下是打印兩個整數(shù)的最大值的示例代碼：

package cn.java4u.flowcontrol; 
 
import java.util.Scanner; 
 
/** 
 * if 單選擇結(jié)構(gòu) 
 * 
 * @author 蝸牛 
 * @from 公眾號：蝸?；ヂ?lián)網(wǎng) 
 */ 
public class IfSingleChoiceDemo { 
 
    public static void main(String[] args) { 
 
        // 用標(biāo)準(zhǔn)的輸入流構(gòu)建一個 Scanner 對象 
        Scanner scanner = new Scanner(System.in); 
 
        System.out.println("請輸入整數(shù)a:"); 
        int a = scanner.nextInt(); 
 
        System.out.println("請輸入整數(shù)b:"); 
        int b = scanner.nextInt(); 
 
        // 初始化最大值為 a 的值 
        int max = a; 
 
        // b 比 a 大的請求下，把 b 的值賦給 max 
        if (a < b) { 
            max = b; 
        } 
        System.out.println("max:" + max); 
    } 
} 

我們用數(shù)字 a 初始化了變量 max，只有發(fā)現(xiàn) b 比 a 大的時候，才會把 b 的值賦給 max。也就是 當(dāng) a=10 并且 b=9 時，if 花括號里的邏輯是走不到的，當(dāng) a=10 并且 b=11 時，if 花括號里的邏輯會走到。

if雙選擇結(jié)構(gòu)

有時候我們遇到某個條件，會有兩種不同的邏輯，此時可以使用if雙選擇結(jié)構(gòu)。

語法如下：

if(布爾表達(dá)式){ 
 //布爾表達(dá)式結(jié)果為 true 時執(zhí)行的語句 
}else{ 
 //布爾表達(dá)式結(jié)果為 false 時執(zhí)行的語句 
} 

以下是打印整數(shù)絕對值的示例代碼：

package cn.java4u.flowcontrol; 
 
import java.util.Scanner; 
 
/** 
 * if雙選擇結(jié)構(gòu) 
 * 
 * @author 蝸牛 
 * @from 公眾號：蝸牛互聯(lián)網(wǎng) 
 */ 
public class IfDoubleChoiceDemo { 
    public static void main(String[] args) { 
 
        // 用標(biāo)準(zhǔn)的輸入流構(gòu)建一個 Scanner 對象 
        Scanner scanner = new Scanner(System.in); 
 
        System.out.println("請輸入整數(shù)a:"); 
        //10,-10 切換 
        int a = scanner.nextInt(); 
 
        // 初始化絕對值變量 
        int abs; 
 
        if (a < 0) { 
            abs = -a; 
        } else { 
            abs = a; 
        } 
        System.out.println("abs:" + abs); 
    } 
} 

我們用 abs 初始化了絕對值變量，針對待判定的整數(shù) a，當(dāng)它的值是 10 或者 -10 時，會走 if 的不同分支執(zhí)行不一樣的邏輯。

if多選擇結(jié)構(gòu)

當(dāng)我們遇到的條件不只一個的時候，我們執(zhí)行邏輯的情況可能會超過兩個，此時可以使用if多選擇結(jié)構(gòu)。

語法如下：

 

if(布爾表達(dá)式1){ 
 //布爾表達(dá)式1結(jié)果為 true 時執(zhí)行的語句 
}else if(布爾表達(dá)式2){ 
 //布爾表達(dá)式2結(jié)果為 true 時執(zhí)行的語句 
}     
else{ 
 //布爾表達(dá)式結(jié)果為 false 時執(zhí)行的語句 
} 

以下是百分制成績評優(yōu)良差的示例代碼：

package cn.java4u.flowcontrol; 
 
import java.util.Scanner; 
 
/** 
 * if 多選擇結(jié)構(gòu) 
 * 
 * @author 蝸牛 
 * @from 公眾號：蝸?；ヂ?lián)網(wǎng) 
 */ 
public class IfMultiChoiceDemo { 
 
    public static void main(String[] args) { 
        // 用標(biāo)準(zhǔn)的輸入流構(gòu)建一個 Scanner 對象 
        Scanner scanner = new Scanner(System.in); 
 
        System.out.println("請輸入你的成績（百分制）:"); 
 
        //58,68,88,96,120 切換 
        int score = scanner.nextInt(); 
 
        if (score > 0 && score < 60) { 
            System.out.println("不合格"); 
        } else if (score >= 60 && score < 80) { 
            System.out.println("合格"); 
        } else if (score >= 80 && score < 90) { 
            System.out.println("良好"); 
        } else if (score >= 90 && score <= 100) { 
            System.out.println("優(yōu)秀"); 
        } else { 
            System.out.println("非法輸入"); 
        } 
    } 
} 

成績分?jǐn)?shù)評優(yōu)良差的程序存在區(qū)間多級判斷，比較適合if多選擇結(jié)構(gòu)。

if嵌套選擇結(jié)構(gòu)

當(dāng)我們遇到的條件里，又能拆出多個條件，有不同的執(zhí)行邏輯時，可以使用if嵌套選擇結(jié)構(gòu)。if嵌套選擇結(jié)構(gòu)可以認(rèn)為是if多選擇結(jié)構(gòu)的變種。

語法如下：

if(布爾表達(dá)式1){ 
 //布爾表達(dá)式1結(jié)果為 true 時執(zhí)行的語句 
     
    if(布爾表達(dá)式2){ 
        //布爾表達(dá)式2結(jié)果為 true 時執(zhí)行的語句 
    } 
} 

以下是百分制成績評優(yōu)良差變形后的示例代碼：

package cn.java4u.flowcontrol; 
 
import java.util.Scanner; 
 
/** 
 * if嵌套選擇結(jié)構(gòu) 
 * 
 * @author 蝸牛 
 * @from 公眾號：蝸?；ヂ?lián)網(wǎng) 
 */ 
public class IfNestChoiceDemo { 
    public static void main(String[] args) { 
 
        // 用標(biāo)準(zhǔn)的輸入流構(gòu)建一個 Scanner 對象 
        Scanner scanner = new Scanner(System.in); 
 
        System.out.println("請輸入你的成績（百分制）:"); 
 
        //58,68,88,96,120 切換 
        int score = scanner.nextInt(); 
 
        if (score >= 0 && score <= 100) { 
 
            if (score < 60) { 
                System.out.println("不合格"); 
            } else if (score < 80) { 
                System.out.println("合格"); 
            } else if (score < 90) { 
                System.out.println("良好"); 
            } else { 
                System.out.println("優(yōu)秀"); 
            } 
 
        } else { 
            System.out.println("非法輸入"); 
        } 
    } 
} 

和普通的 if多選擇結(jié)構(gòu) 的代碼不同在于，if嵌套選擇做了兩層選擇，第一層是輸入的合法性，第二層是對成績做分級。

switch選擇結(jié)構(gòu)

我們有時候遇到的條件比較有限，并且就是判斷一個變量與一系列中某個值是否相等，然后命中不同的值，會走向不同的邏輯。此時就可以使用switch選擇結(jié)構(gòu)。

語法如下：

switch(var){ 
    case value1: 
        // var 命中 value1 時執(zhí)行的語句 
        break; 
    case value2: 
        // var 命中 value2 時執(zhí)行的語句 
        break; 
    //可以有任意數(shù)量的case語句 
    // 默認(rèn)的請求，上邊都沒命中，會走到該分支 
    default: 
        //以上 case 都未命中或者未 break 會走到這里 
} 

我們?nèi)绻焉线吿岬降膸讉€程序打包給用戶使用，那就可以通過 switch 來提供統(tǒng)一的入口，引導(dǎo)用戶鍵入1來路由到求最大值的程序里，鍵入2路由到求絕對值的程序里，鍵入3路由到成績分?jǐn)?shù)評優(yōu)良差的程序里。示例代碼如下：

package cn.java4u.flowcontrol; 
 
import java.util.Scanner; 
 
/** 
 * switch選擇結(jié)構(gòu) 
 * 
 * @author 蝸牛 
 * @from 公眾號：蝸?；ヂ?lián)網(wǎng) 
 */ 
public class IfSwitchChoiceDemo { 
    public static void main(String[] args) { 
 
        // 用標(biāo)準(zhǔn)的輸入流構(gòu)建一個 Scanner 對象 
        Scanner scanner = new Scanner(System.in); 
 
        System.out.println("請選擇你要運行的程序(鍵入1表示求最大值，鍵入2表示求絕對值，鍵入3表示成績分?jǐn)?shù)評優(yōu)良差):"); 
 
        int choice = scanner.nextInt(); 
 
        switch (choice) { 
            case 1: 
                System.out.println("--開始求兩個數(shù)的最大值--"); 
                IfSingleChoiceDemo.main(null); 
                break; 
            case 2: 
                System.out.println("--開始求絕對值--"); 
                IfDoubleChoiceDemo.main(null); 
                break; 
            case 3: 
                System.out.println("--開始成績分?jǐn)?shù)評優(yōu)良差--"); 
                IfMultiChoiceDemo.main(null); 
                break; 
            default: 
                System.out.println("非法輸入"); 
        } 
    } 
} 

跑一下這個程序，鍵入 1 你會發(fā)現(xiàn)開始執(zhí)行求最大值的子程序里，最大值打印后整個程序就結(jié)束了，這說明 break 起到了當(dāng)前分支阻斷程序的作用。一旦命中 break 代碼，后邊的 case 2、case 3、default 都不會走到。

當(dāng)然不是每個 case 都需要有 break 的，當(dāng)你有兩個 case 的邏輯一致，就可以忽略 break 進(jìn)行 case 合并，比如當(dāng)鍵入 4 的時候，我要求和 3 效果一致，可以改成下面這樣：

case 3: 
case 4: 
    System.out.println("--開始成績分?jǐn)?shù)評優(yōu)良差--"); 
    IfMultiChoiceDemo.main(null); 
    break; 

沒有 break 的 case 邏輯會穿透到下一個 case，使用下一個 case 的代碼邏輯。

注意，switch選擇結(jié)構(gòu)是if多選擇結(jié)構(gòu)特殊場景下的變種，JavaSE 8 支持的變量類型有 byte、short、int、char、String、ENUM。

循環(huán)結(jié)構(gòu)

程序有時候會重復(fù)運行一段邏輯，如果按順序結(jié)構(gòu)+選擇結(jié)構(gòu)來組織代碼的話，這種情況下需要寫很多重復(fù)的代碼才能實現(xiàn)。比如我要得到從 1 到 5 的和：

1+2+3+4+5=? 

我的代碼可能就是這樣：

package cn.java4u.flowcontrol; 
 
/** 
 * while 循環(huán)結(jié)構(gòu)演示 
 * 
 * @author 蝸牛 
 * @from 公眾號：蝸?；ヂ?lián)網(wǎng) 
 */ 
public class WhileCircleDemo { 
 
    public static void main(String[] args) { 
 
        int a = 1; 
        int sum = 0; 
 
        System.out.println("當(dāng)前a的值為:" + a); 
        // a 累加到 sum 中 
        sum = sum + a; 
        // a 自身加一 
        a = a + 1; 
 
        System.out.println("當(dāng)前a的值為:" + a); 
        sum = sum + a; 
        a = a + 1; 
 
        System.out.println("當(dāng)前a的值為:" + a); 
        sum = sum + a; 
        a = a + 1; 
 
        System.out.println("當(dāng)前a的值為:" + a); 
        sum = sum + a; 
        a = a + 1; 
 
        System.out.println("當(dāng)前a的值為:" + a); 
        sum = sum + a; 
         
        System.out.println("sum:" + sum); 
 
    } 
} 

你會發(fā)現(xiàn)重復(fù)邏輯很多，在 a = 5 的時候，累加才結(jié)束，結(jié)果才輸出。那如果有種機(jī)制能把這些重復(fù)的邏輯用簡潔的方式表達(dá)，那寫代碼就會方便很多。

這種機(jī)制就是循環(huán)結(jié)構(gòu)。

while循環(huán)結(jié)構(gòu)

最常用的循環(huán)結(jié)構(gòu)是 while 循環(huán)，語法如下：

while(布爾表達(dá)式){ 
 //循環(huán)內(nèi)容 
} 

• 只要布爾表達(dá)式為 true，循環(huán)就會一直執(zhí)行下去。
• 我們大多數(shù)情況是會讓循環(huán)停止下來的，因此需要一個讓布爾表達(dá)式為 false 的方式來停止循環(huán)。
• 少部分情況時需要循環(huán)一直執(zhí)行，比如服務(wù)器的請求響應(yīng)監(jiān)聽等。
• 循環(huán)條件如果一直是 true，就會造成無限循環(huán)，應(yīng)盡量避免這種情況，否則會造成程序卡死崩潰。

用 while 來表達(dá)求和代碼如下：

// 初始化值 
a = 1; 
sum = 0; 
 
while (a <= 5) { 
    // a 累加到 sum 中 
    sum += a; 
    // a 自身加一 
    a++; 
} 
System.out.println("while sum:" + sum); 

do while循環(huán)結(jié)構(gòu)

觀察 while 語句，你會發(fā)現(xiàn)，只要不滿足條件，就不能進(jìn)入循環(huán)。但有時候我們需要即使不滿足條件，也至少要執(zhí)行一次。那此時用 do while 循環(huán)就比較合適，語法如下：

do{ 
 //循環(huán)內(nèi)容 
}where(布爾表達(dá)式) 

• 不同于 while 循環(huán)結(jié)構(gòu)的先判斷后執(zhí)行的方式，do while 循環(huán)結(jié)構(gòu)是先執(zhí)行后判斷。
• do while 中的循環(huán)內(nèi)容會被至少執(zhí)行一次。

用 do while 來表達(dá)求和代碼如下：

// 初始化值 
a = 1; 
sum = 0; 
 
do { 
    // a 累加到 sum 中 
    sum += a; 
    // a 自身加一 
    a++; 
} while (a <= 5); 
System.out.println("do while sum:" + sum); 

for循環(huán)結(jié)構(gòu)

在求和代碼中，我們會發(fā)現(xiàn)，a 就像一個計數(shù)器，通過 a = 1 初始化一個值，然后在每次循環(huán)中加一來當(dāng)成我們求和時要加的那個數(shù)，a <= 5 作為計數(shù)器循環(huán)檢測條件，決定了我們的累加是加到 5 還是 100，只要改成 a <= 100，累加到 100 就不會再執(zhí)行循環(huán)。

這種其實是迭代處理的通用結(jié)構(gòu)：初始值、終止條件和計數(shù)器。于是 Java 提供了 for 循環(huán)結(jié)構(gòu)，用來簡化這種場景下的 while 循環(huán)，語法如下：

for(計數(shù)器初始化; 布爾表達(dá)式; 循環(huán)后更新計數(shù)器){ 
 //循環(huán)內(nèi)容 
} 

用 for 來表達(dá)求和代碼如下：

sum = 0; 
for (a = 1; a <= 5; a++) { 
    sum += a; 
} 
System.out.println("for sum:" + sum); 

for each循環(huán)結(jié)構(gòu)

有些時候，我們拿到一堆數(shù)處理，其實并不關(guān)心他們的次序，只要能遍歷到就可以。比如數(shù)組里的幾個值，我不關(guān)心值的索引，我只想知道這些值的總和是多少。此時就可以用 for each 循環(huán)結(jié)構(gòu)，它可以很簡單的遍歷數(shù)組，語法如下：

for(元素類型 元素變量 : 數(shù)組或迭代器){ 
 //循環(huán)內(nèi)容 
} 

• for each 是對 for 特殊場景下的簡化，處理對象是數(shù)組或者迭代器對象。
• 和 for 循環(huán)結(jié)構(gòu)相比，for each 循環(huán)結(jié)構(gòu)不再體現(xiàn)計數(shù)器的初始化和更新，因此也無法指定遍歷順序，也不能獲取數(shù)組或迭代器索引。

用 for each 來表達(dá)求和代碼如下：

int[] array = {1, 2, 3, 4, 5}; 
sum = 0; 
for (int temp : array) { 
    sum += temp; 
} 
System.out.println("for each sum:" + sum); 

循環(huán)結(jié)構(gòu)的中斷

循環(huán)結(jié)構(gòu)都會有個布爾表達(dá)式作為循環(huán)檢測條件，如果布爾表達(dá)式為 false 時，就會終止循環(huán)，這是循環(huán)中斷的一種方式。

除此之外，Java 還提供了另外兩種循環(huán)結(jié)構(gòu)中斷的方式。

一種是 break。語法如下：

循環(huán)結(jié)構(gòu){ 
    //中斷前代碼 
    if(中斷布爾表達(dá)式){ 
  break; 
    } 
    //中斷后代碼 
} 

• 中斷布爾表達(dá)式返回 true 時，命中 break ，直接退出整個循環(huán)結(jié)構(gòu)，中斷后代碼不再執(zhí)行。

求和示例代碼如下：

int a = 1; 
int sum = 0; 
while (a <= 5) { 
 
    // a 為 3 的時候中斷 
    if (a == 3) { 
        break; 
    } 
 
    // a 累加到 sum 中 
    sum += a; 
    // a 自身加一 
    a++; 
} 
System.out.println("while sum:" + sum); 

實際對 1 和 2 進(jìn)行求和，因為 a 為 3 的時候退出了循環(huán)。

注意：循環(huán)結(jié)構(gòu)如果存在嵌套，break 只會退出當(dāng)前層循環(huán)結(jié)構(gòu)，不會退出外層循環(huán)結(jié)構(gòu)。

另一種是 continue，語法如下：

循環(huán)結(jié)構(gòu){ 
    //中斷前代碼 
    if(中斷布爾表達(dá)式){ 
  continue; 
    } 
    //中斷后代碼 
} 

• 中斷布爾表達(dá)式返回 true 時，命中 continue ，該循環(huán)結(jié)構(gòu)當(dāng)次調(diào)用中斷，中斷后代碼當(dāng)次不再執(zhí)行，進(jìn)入循環(huán)結(jié)構(gòu)的下次調(diào)用。

示例代碼如下：

int i = 0; 
while (i <= 5) { 
    i++; 
    // i 為 3 的時候中斷 
    if (i == 3) { 
        System.out.println("命中 continue"); 
        continue; 
    } 
    System.out.println("i=" + i); 
} 

輸出：

i=1 
i=2 
命中 continue 
i=4 
i=5 
i=6 

會發(fā)現(xiàn) i 的值為 3 的時候命中 continue 邏輯，當(dāng)次循環(huán)不會繼續(xù)往下走，但會進(jìn)入下一次循環(huán)。

簡單講，break 跳出當(dāng)前層循環(huán)，循環(huán)結(jié)構(gòu)中止，continue 跳出當(dāng)次循環(huán)調(diào)用，當(dāng)次調(diào)用中止。二者都要配合 if 使用。

小結(jié)

 

本文從現(xiàn)實案例引出了流程控制的概念，映射到編程領(lǐng)域，我們把一個程序的執(zhí)行，抽象成輸入-處理-輸出的過程。然后介紹了在 Java 的世界里，輸入和輸出的實現(xiàn)方式，接著講解了在處理的過程中，常用的三種流程控制結(jié)構(gòu)：順序結(jié)構(gòu)、選擇結(jié)構(gòu)和循環(huán)結(jié)構(gòu)，并列出了演示代碼。讀者可以仿照案例實踐一把，相信你會有更深刻的印象。感謝你的閱讀和分享，歡迎留言互動和點贊!