Java 流程控制核心筆記：分支、迴圈與最佳實踐

流程控制三大類別

• 順序結構：程式碼自上而下依序執行，無判斷與跳轉。
• 條件控制（分支結構）：根據條件選擇執行路徑，包含 if、switch。
• 迴圈控制：根據條件重複執行，包含 while、do-while、for。

分支結構詳解

1. if-else 多重判斷

Scanner sc = new Scanner(System.in);
System.out.print("請輸入分數 (0-100)：");
int score = sc.nextInt();

if (score < 0 || score > 100) {
    System.out.println("輸入不合法");
} else if (score >= 90) {
    System.out.println("優秀");
} else if (score >= 75) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("合格");
} else {
    System.out.println("不合格");
}

關鍵點：條件由嚴格到寬鬆排序，避免邏輯漏洞；使用區間判斷替代多重等值比較。

2. switch-case（Java 12+ 支援表達式寫法）

// 傳統寫法
switch (score / 10) {
    case 10:
    case 9:
        System.out.println("優秀");
        break;
    case 8:
    case 7:
        System.out.println("良好");
        break;
    case 6:
        System.out.println("合格");
        break;
    default:
        System.out.println("不合格");
}

// Java 12+ Switch 表達式（建議）
String grade = switch (score / 10) {
    case 10, 9 -> "優秀";
    case 8, 7 -> "良好";
    case 6 -> "合格";
    default -> "不合格";
};
System.out.println(grade);

注意：switch 支援 byte、short、char、int、String、enum；不支援 long、float、double、boolean。

迴圈結構詳解

1. while 迴圈（先判斷後執行）

int i = 1;
while (i <= 100) {
    System.out.println(i);
    i++;
}

適用於次數未知、依條件決定是否執行的場景。

2. do-while 迴圈（先執行後判斷）

int a = 1;
do {
    System.out.println(a); // 至少執行一次
    a++;
} while (a <= 0); // 條件為 false，但已執行一次

適用於至少執行一次的場景（如選單驅動程式）。

3. for 迴圈（計數器驅動）

for (int i = 1; i <= 100; i++) {
    System.out.println(i);
}

增強版 for-each（Java 5+）：遍歷陣列/集合

int[] nums = {1, 6, 2, 2, 5};
for (int num : nums) {
    System.out.println(num);
}

迴圈控制關鍵字

outer: for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) break outer; // 直接跳出外層迴圈
        System.out.println(i + "," + j);
    }
}

實戰範例：冒泡排序與優化

基礎版

public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

優化版：旗標提前結束

public static void bubbleSortOptimized(int[] arr) {
    boolean swapped;
    for (int i = 0; i < arr.length - 1; i++) {
        swapped = false;
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) break; // 本輪無交換，已有序
    }
}

進階優化：記錄最後交換位置

public static void bubbleSortAdvanced(int[] arr) {
    int n = arr.length;
    while (n > 1) {
        int newN = 0;
        for (int j = 1; j < n; j++) {
            if (arr[j - 1] > arr[j]) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
                newN = j; // 記錄最後交換位置
            }
        }
        n = newN; // 下輪只需掃描到最後交換位置
    }
}

效能與複雜度分析

結論：冒泡排序教學價值大於實用價值，實務上優先使用 Arrays.sort()（雙軸快速排序）或 Collections.sort()（TimSort）。

常見錯誤與除錯技巧

1. 邊界條件錯誤

迴圈條件寫成 i <= length 導致 ArrayIndexOutOfBoundsException。習慣：使用 i < length 或 for-each 避免手動索引。

2. 無限迴圈

忘記更新迴圈變數，或條件永遠為真。技巧：IDE 設置「無限迴圈檢測」、單元測試覆蓋邊界案例。

3. switch 遺漏 break

導致「貫穿」執行下一個 case。建議：使用 Java 12+ 表達式寫法或加上 // fall through 註解。

4. 浮點數比較陷阱

if (0.1 + 0.2 == 0.3) 為 false。解決：使用 BigDecimal 或設定容差值 Math.abs(a - b) < 1e-9。

最佳實踐總結

1. 優先使用 for-each 遍歷集合/陣列，減少索引錯誤。
2. 條件判斷採用「護衛條款」風格：先處理異常/邊界情況 return，主流程保持淺層縮排。
3. 複雜條件提取為具名布林方法：if (isEligibleForDiscount(user)) 而非 if (user.getAge() > 60 && user.getVipLevel() > 2 ...)。
4. 迴圈體保持精簡，複雜邏輯抽取為獨立方法。
5. 效能敏感場景避免在迴圈中建立物件、字串拼接（使用 StringBuilder）。