您现在的位置：程式碼之家 >> 編程語言 > >> Java 程式設計 >> Java 綜合教學

Java 8 Lambda 表達式完全指南：從語法到原理、從函數式接口到 Stream 實戰

編輯：Java 綜合教學

為什麼 Java 需要 Lambda？

Java 長期堅持「一切皆對象」，函數無法獨立存在。函數式編程語言 (JS, Scala, Kotlin) 中函數是一等公民，可賦值、傳參、返回。Lambda 為 Java 引入函數值概念，使代碼更簡潔、並行處理更容易、集合操作更聲明式。

核心對比：匿名內部類 vs Lambda

// 匿名內部類 (冗長)
Runnable r1 = new Runnable() {
    @Override public void run() { System.out.println("Hello"); }
};

// Lambda (精煉)
Runnable r2 = () -> System.out.println("Hello");

函數式接口：Lambda 的類型系統基石

定義與 @FunctionalInterface

@FunctionalInterface
public interface MyComparator {
    int compare(T a, T b); // 唯一抽象方法 (SAM)
    
    // 默認方法、靜態方法、Object 方法不破壞函數式接口性質
    default void print() { System.out.println("default"); }
    static MyComparator byLength() { return (a,b) -> a.length()-b.length(); }
}

SAM (Single Abstract Method)：有且僅有一個抽象方法
@FunctionalInterface 編譯期校驗，防止誤添加抽象方法
常見內置函數式接口：Runnable, Callable, Comparator, ActionListener

Lambda 類型推導

Lambda 本身無類型，其類型由目標類型上下文決定：

// 同一 Lambda 可適配不同函數式接口
Comparator c1 = (a,b) -> a-b;
MyComparator c2 = (a,b) -> a-b; // 自定義接口
// 編譯器根據賦值目標推導類型

Lambda 語法全解析

三要素結構

(參數列表) -> { 方法體 }

完整語法變體

形式	示例	說明
無參、表達式體	`() -> 42`	返回 int
單參、類型推導	`x -> x * x`	圓括號可省略
單參、顯式類型	`(int x) -> x * x`	需括號
多參、推導	`(x, y) -> x + y`
多參、顯式類型	`(int x, int y) -> x + y`	所有參數必須同樣顯式/推導
代碼塊體、有返回	`(x, y) -> { int z = x+y; return z; }`	需 `return`、分號、大括號
代碼塊體、無返回	`(String s) -> { System.out.println(s); }`	void 兼容
方法引用	`String::valueOf`	靜態方法引用
實例方法引用	`System.out::println`	對象::實例方法
構造器引用	`ArrayList::new`	類::new

語法限制

不能直接拋出受檢異常，除非目標接口聲明
不能使用 break/continue 跳出外層循環
不能用 return 從外層方法返回 (只能從 Lambda 體返回)
捕獲變量必須 實質上 final (編譯期不可變)

變量捕獲與作用域

捕獲規則

public class LambdaScope {
    static int staticVar = 10;      // 靜態變量：可讀寫
    int instanceVar = 20;           // 實例變量：可讀寫 (捕獲 this)
    
    public void demo() {
        int localVar = 30;          // 局部變量：隱式 final，不可修改
        // localVar = 40; // 編譯錯誤！
        
        Runnable r = () -> {
            System.out.println(staticVar);   // OK
            System.out.println(instanceVar); // OK (捕獲 this)
            System.out.println(localVar);    // OK (捕獲值)
            staticVar++;        // OK 修改靜態
            instanceVar++;      // OK 修改實例
            // localVar++;       // 錯誤：局部變量不可變
        };
    }
}

捕獲 vs 非捕獲性能

非捕獲 Lambda：無外部變量引用，編譯器生成 private static 方法，調用 invokedynamic 只創建單例實例
捕獲 Lambda：每次調用創建新實例 (類似匿名內部類)，攜帶捕獲值/引用

Java 8 內置函數式接口大全 (java.util.function)

接口	參數	返回	核心方法	典型用途
`Predicate`	T	boolean	test(T)	過濾、斷言
`Consumer`	T	void	accept(T)	消費、副作用 (打印、寫入)
`Function`	T	R	apply(T)	轉換、映射
`Supplier`	無	T	get()	延遲生成、工廠
`UnaryOperator`	T	T	apply(T)	同類型轉換
`BinaryOperator`	T,T	T	apply(T,T)	歸約、合併
`BiFunction`	T,U	R	apply(T,U)	雙參數轉換

另有 IntPredicate, LongConsumer, DoubleFunction 等基本類型特化版，避免裝箱拆箱開銷。

組合式 API

// Predicate 組合
Predicate nonNull = s -> s != null;
Predicate nonEmpty = s -> !s.isEmpty();
Predicate valid = nonNull.and(nonEmpty); // 且
Predicate invalid = nonNull.negate();    // 非

// Function 鏈式
Function f1 = x -> x + 1;
Function f2 = x -> x * 2;
Function f3 = f1.andThen(f2); // (x+1)*2
Function f4 = f1.compose(f2); // (x*2)+1

// Consumer 鏈式
Consumer c1 = s -> System.out.print("[");
Consumer c2 = s -> System.out.print(s);
Consumer c3 = s -> System.out.println("]");
Consumer combined = c1.andThen(c2).andThen(c3);

Lambda 實戰：集合操作與 Stream API

經典場景對比

List names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// 1. 遍歷打印
names.forEach(System.out::println); // 方法引用

// 2. 過濾長度>3 轉大寫 收集
List result = names.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());
// [ALICE, CHARLIE, DAVID]

// 3. 分組統計
Map> byLength = names.stream()
    .collect(Collectors.groupingBy(String::length));

// 4. 歸約求和
int totalLen = names.stream()
    .mapToInt(String::length)
    .sum(); // 或 .reduce(0, (a,b) -> a+b)

// 5. 查找首個
Optional firstLong = names.stream()
    .filter(s -> s.length() > 5)
    .findFirst(); // Optional[CHARLIE]

// 6. 並行流 (多核利用)
long count = names.parallelStream()
    .filter(s -> s.length() > 3)
    .count();

Stream 三大操作類別

中間操作：filter, map, flatMap, distinct, sorted, peek, limit, skip — 惰性、返回新 Stream
終端操作：forEach, collect, reduce, count, min/max, findFirst/any, any/all/noneMatch — 觸發計算
短路操作：limit, findFirst, anyMatch — 可提前終止

Lambda 運行時機制：invokedynamic 與 LambdaMetafactory

編譯期

Lambda 體提取為 private static 方法 (非捕獲) 或 private 實例方法 (捕獲)
生成 invokedynamic 指令點 (Call Site)，而非匿名類 .class 文件

運行期 (首次調用)

invokedynamic 指令
    │
    ▼
LambdaMetafactory.metafactory(MethodHandles.Lookup, String, MethodType, ...)
    │
    ▼
動態生成實現目標函數式接口的類 (ASM)
    │
    ▼
返回 CallSite，緩存後續調用直接使用

優勢

啟動快：無額外 .class 文件加載/驗證
內存省：非捕獲單例，捕獲僅攜帶必要值
優化空間大：JVM 可內聯 Lambda 體、逃逸分析、標量替換
未來兼容：不綁定匿名類實現，可演進 (如值類型、模式匹配)

方法引用四種形式

類型	語法	等價 Lambda	示例
靜態方法	`Class::staticMethod`	`(args) -> Class.staticMethod(args)`	`Integer::parseInt`
實例方法 (特定對象)	`obj::method`	`(args) -> obj.method(args)`	`System.out::println`
實例方法 (任意對象)	`Class::method`	`(obj, args) -> obj.method(args)`	`String::toUpperCase`
構造器	`Class::new`	`(args) -> new Class(args)`	`ArrayList::new`

Lambda 不能做的事 (Java 8 限制)

非 final 變量捕獲：int i=0; list.forEach(s -> i++); // 編譯錯誤 → 用 AtomicInteger 或數組 int[] cnt={0}
受檢異常透傳：Lambda 體拋出受檢異常需目標接口聲明 → 自定義函數式接口或包裝為 RuntimeException
控制流跳出：break/continue/return 無法作用於外層循環/方法 → 改用流操作 filter/findFirst 或傳統循環

最佳實踐棧單

優先用方法引用：list.forEach(System.out::println) 比 list.forEach(x -> System.out.println(x)) 更清晰
避免過度鏈式：超過 3-4 個中間操作考慮拆分為中間變量
並行流謹慎用：數據量小/操作輕時開銷大於收益；有狀態操作 (distinct, sorted) 並行效果差
基本類型流：IntStream, LongStream, DoubleStream 避免裝箱
Optional 鏈式：Optional.ofNullable(user).map(User::getAddress).map(Address::getCity).orElse("Unknown")
序列化警示：Lambda 實例只有在目標接口繼承 Serializable 時才可序列化

Lambda 表達式不僅是語法糖，更是 Java 向函數式編程邁出的關鍵一步。配合 Stream API、Optional、CompletableFuture，構建了現代 Java 聲明式、可組合、並行友好的編程模型。掌握其語法、類型系統、捕獲語義與運行機制，是寫出優雅、高性能 Java 代碼的必修課。