Java 8 Lambda 表達式核心語法與函數式編程實戰指南

從匿名內部類到 Lambda：Java 函數式編程範式轉變全解析

Java 8 引入 Lambda 表達式（JSR 335），標誌著 Java 正式擁抱函數式編程。本文基於《Java SE 8 for the Really Impatient》讀書筆記，系統梳理 Lambda 語法規則、函數式接口體系、方法引用、構造器引用、變量捕獲語義，並對比傳統匿名內部類展示代碼簡化效果。

一、 Lambda 表達式語法全景

// 完整語法
(參數列表) -> { 方法體 }

// 核心規則：
// 1. 參數類型可省略（編譯器類型推導）
// 2. 單參數且類型可推導時，括號可省略
// 3. 單語句方法體可省略大括號與 return 關鍵字
// 4. 多語句必須用大括號包裹，且必須有返回值（非 void 類型）

各種形式示例

二、 函數式接口：Lambda 的類型載體

定義：有且僅有一個抽象方法的接口（SAM - Single Abstract Method）。可用 @FunctionalInterface 註解標記，編譯器會強制校驗。

JDK 內置函數式接口速查表 (java.util.function)

Lambda 創建函數式接口實例對比

// 傳統匿名內部類 (Java 7)
new Thread(new Runnable() {
    @Override public void run() { System.out.println(Thread.currentThread().getName()); }
}).start();

// Lambda (Java 8+)
Runnable runner = () -> System.out.println(Thread.currentThread().getName());
new Thread(runner).start();
// 或直接
new Thread(() -> System.out.println(Thread.currentThread().getName())).start();

// Comparator 排序
// 匿名內部類
Arrays.sort(strings, new Comparator() {
    public int compare(String a, String b) { return Integer.compare(a.length(), b.length()); }
});

// Lambda
Arrays.sort(strings, (a, b) -> Integer.compare(a.length(), b.length()));
// 方法引用（下節詳述）
Arrays.sort(strings, Comparator.comparingInt(String::length));

三、 方法引用：Lambda 的語法糖升級版

當 Lambda 體僅調用一個現有方法時，可用 :: 運算符引用該方法，增強可讀性。

四種方法引用形式

實戰示例：排序與流式處理

List list = Arrays.asList("Mary", "had", "a", "little", "lamb");

// 1. 任意對象實例方法引用：String.compareToIgnoreCase(String)
// Comparator 需要 (String, String) -> int
// String::compareToIgnoreCase 簽名為 (String) -> int，第一個參數成為調用者
list.sort(String::compareToIgnoreCase); 

// 2. 靜態方法引用：自定義比較器
public class MyUtils {
    public static int compareByLength(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
}
list.sort(MyUtils::compareByLength);

// 3. 構造器引用：Stream 轉數組
Stream stream = labels.stream().map(Button::new);
Button[] buttons = stream.toArray(Button[]::new); // String[]::new 對應 IntFunction

// 4. 實例方法引用（特定對象）：this::method / super::method
class Greeter {
    void greet() { System.out.println("Hello"); }
}
class AsyncGreeter extends Greeter {
    void greetAsync() {
        new Thread(super::greet).start(); // 引用父類方法
    }
}

四、 變量捕獲與作用域規則：Effectively Final

Lambda 只能捕獲 final 或 effectively final（實際上不可變） 的局部變量。

規則對比

代碼示例

public void repeatMessage(String text, int count) {
    // count 未聲明 final，但初始化後未修改 → effectively final ✅
    Runnable r = () -> {
        for (int i = 0; i < count; i++) { // 捕獲 count 的值
            System.out.println(text);     // 捕獲 text 的值
        }
    };
    new Thread(r).start();
}

public void repeatMessage2(String text, int count) {
    // count 在 Lambda 內部修改 → 編譯錯誤 ❌
    Runnable r = () -> {
        while (count > 0) { // Error: Variable used in lambda expression should be final or effectively final
            count--; 
            System.out.println(text);
        }
    };
}

// 變通方案：使用可變容器（單元素數組/AtomicInteger）
public void repeatMessage3(String text, int count) {
    AtomicInteger counter = new AtomicInteger(count); // 線程安全可變容器
    Runnable r = () -> {
        while (counter.getAndDecrement() > 0) {
            System.out.println(text);
        }
    };
    new Thread(r).start();
}

// 實例/靜態字段無限制（捕獲 this 引用）
private int instanceCount;
public void useField() {
    Runnable r = () -> { instanceCount++; }; // ✅ 合法，但需注意線程安全
}

五、 最佳實踐與避坑指南

1. 優先使用方法引用：邏輯提取為獨立方法，配合方法引用，代碼更清晰、可復用、易測試。
2. 避免長 Lambda：超過 3 行邏輯請提取為私有方法，保持 Lambda 單一職責。
3. 警惕 this 捕獲：Lambda 內使用 this 指向外部類實例，若長生命周期持有 Lambda 會阻礙外部對象 GC。
4. 線程安全第一：捕獲可變共享狀態（如 List、Map、計數器）必須使用線程安全容器或同步機制。
5. 序列化風險：Lambda 實現了 Serializable 只有當目標類型也是 Serializable 時才可序列化（如分佈式框架 Spark/Flink 需注意）。
6. 調試難點：堆疊信息顯示 lambda$method$0，建議提取關鍵邏輯為命名方法便於調試。
7. 函數式接口選型：優先使用 java.util.function 標準接口，避免自定義單方法接口造成生態割裂。

六、 進階：自定義函數式接口與默認方法

@FunctionalInterface
public interface Calculator {
    T calculate(T a, T b);
    
    // 默認方法：提供通用輔助能力，不破壞函數式接口定義
    default Calculator andThen(Calculator after) {
        return (a, b) -> after.calculate(this.calculate(a, b), b);
    }
}

// 使用
Calculator add = (a, b) -> a + b;
Calculator mul = (a, b) -> a * b;
Calculator addThenMul = add.andThen(mul);
System.out.println(addThenMul.calculate(2, 3)); // (2+3)*3 = 15

Lambda 表達式不僅是語法糖，更是 Java 向聲明式、數據流編程邁出的關鍵一步。配合 Stream API、Optional、CompletableFuture，構成了現代 Java 並發與數據處理的核心工具箱。深入理解其類型推導、捕獲語義與方法引用機制，是寫出優雅、高效、可維護 Java 代碼的必修課。