Java Lambda表達式指南

一、Lambda表達式基礎

1. 什么是Lambda表達式？

匿名函數：沒有名稱的函數
函數式編程：可作為參數傳遞的代碼塊
簡潔語法：替代匿名內部類的更緊湊寫法

2. 基本語法

(parameters) -> expression
或
(parameters) -> { statements; }

3. 與傳統匿名類的對比

// 傳統方式
Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("Hello World");}
};// Lambda方式
Runnable r2 = () -> System.out.println("Hello World");

二、函數式接口

1. 什么是函數式接口？

單抽象方法接口：只有一個抽象方法的接口
可用@FunctionalInterface注解標記

2. Java內置核心函數式接口

接口	方法	用途
`Supplier<T>`	`T get()`	無參返回結果
`Consumer<T>`	`void accept(T t)`	接收單個參數無返回
`Function<T,R>`	`R apply(T t)`	接收T類型返回R類型
`Predicate<T>`	`boolean test(T t)`	接收T返回布爾值
`UnaryOperator<T>`	`T apply(T t)`	一元操作（同類型轉換）
`BiFunction<T,U,R>`	`R apply(T t, U u)`	接收T,U返回R

3. 自定義函數式接口

@FunctionalInterface
interface StringProcessor {String process(String input);// 可以有默認方法default void info() {System.out.println("String processing interface");}
}StringProcessor toUpper = s -> s.toUpperCase();
System.out.println(toUpper.process("hello")); // 輸出: HELLO

三、Lambda使用場景

1. 集合遍歷

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");// 傳統方式
for (String name : names) {System.out.println(name);
}// Lambda方式
names.forEach(name -> System.out.println(name));// 方法引用方式
names.forEach(System.out::println);

2. 線程創建

// 傳統方式
new Thread(new Runnable() {@Overridepublic void run() {System.out.println("Running in thread");}
}).start();// Lambda方式
new Thread(() -> System.out.println("Running in thread")).start();

3. 條件過濾

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);// 過濾偶數
List<Integer> evens = numbers.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());

4. 排序

List<String> words = Arrays.asList("banana", "apple", "pear");// 傳統方式
Collections.sort(words, new Comparator<String>() {@Overridepublic int compare(String a, String b) {return a.compareTo(b);}
});// Lambda方式
Collections.sort(words, (a, b) -> a.compareTo(b));// 更簡潔的方式
words.sort(Comparator.naturalOrder());

四、方法引用

1. 四種方法引用類型

類型	語法	對應的Lambda
靜態方法	`ClassName::staticMethod`	`(args) -> ClassName.staticMethod(args)`
實例方法	`instance::method`	`(args) -> instance.method(args)`
任意對象的實例方法	`ClassName::method`	`(obj, args) -> obj.method(args)`
構造方法	`ClassName::new`	`(args) -> new ClassName(args)`

2. 使用示例

// 靜態方法引用
Function<String, Integer> parser = Integer::parseInt;// 實例方法引用
String str = "Hello";
Supplier<Integer> lengthSupplier = str::length;// 任意對象方法引用
Function<String, String> upperCase = String::toUpperCase;// 構造方法引用
Supplier<List<String>> listSupplier = ArrayList::new;

五、Stream API與Lambda

1. 流操作三階段

創建流：集合、數組等數據源
中間操作：過濾、映射等處理
終止操作：收集、遍歷等結果處理

2. 常用流操作

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");// 過濾并收集
List<String> longNames = names.stream().filter(name -> name.length() > 4).collect(Collectors.toList());// 映射轉換
List<Integer> nameLengths = names.stream().map(String::length).collect(Collectors.toList());// 排序
List<String> sorted = names.stream().sorted((a, b) -> b.compareTo(a)).collect(Collectors.toList());// 聚合操作
Optional<String> longest = names.stream().max(Comparator.comparingInt(String::length));

3. 并行流

long count = names.parallelStream().filter(name -> name.length() > 4).count();

六、Lambda高級特性

1. 變量捕獲

int threshold = 5; // 必須是final或事實上final
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);List<Integer> aboveThreshold = numbers.stream().filter(n -> n > threshold).collect(Collectors.toList());

2. 組合函數

Function<String, Integer> strToInt = Integer::parseInt;
Function<Integer, Integer> square = n -> n * n;Function<String, Integer> squareOfNumber = strToInt.andThen(square);
System.out.println(squareOfNumber.apply("5")); // 輸出: 25Predicate<String> isLong = s -> s.length() > 10;
Predicate<String> containsA = s -> s.contains("a");
Predicate<String> longAndContainsA = isLong.and(containsA);

3. 閉包示例

Function<Integer, Function<Integer, Integer>> adder = x -> y -> x + y;
Function<Integer, Integer> add5 = adder.apply(5);
System.out.println(add5.apply(3)); // 輸出: 8

七、異常處理

1. Lambda中的異常處理

List<String> numbers = Arrays.asList("1", "2", "three", "4");numbers.forEach(s -> {try {System.out.println(Integer.parseInt(s));} catch (NumberFormatException e) {System.out.println("Invalid number: " + s);}
});

2. 編寫可拋出異常的Lambda

@FunctionalInterface
interface ThrowingConsumer<T, E extends Exception> {void accept(T t) throws E;
}static <T> Consumer<T> wrap(ThrowingConsumer<T, Exception> consumer) {return t -> {try {consumer.accept(t);} catch (Exception e) {throw new RuntimeException(e);}};
}// 使用
List<String> files = Arrays.asList("file1.txt", "file2.txt");
files.forEach(wrap(file -> {// 可能拋出IOException的代碼Files.readAllLines(Paths.get(file)).forEach(System.out::println);
}));

八、實際應用案例

1. 事件處理

// Swing按鈕點擊事件
JButton button = new JButton("Click");
button.addActionListener(e -> System.out.println("Button clicked"));// JavaFX事件處理
Button fxButton = new Button("Click");
fxButton.setOnAction(event -> System.out.println("FX Button clicked"));

2. 緩存模式

public class Cache<K, V> {private final Map<K, V> map = new HashMap<>();private final Function<K, V> loader;public Cache(Function<K, V> loader) {this.loader = loader;}public V get(K key) {return map.computeIfAbsent(key, loader);}
}// 使用
Cache<String, BigDecimal> priceCache = new Cache<>(productId -> fetchPriceFromDatabase(productId));
BigDecimal price = priceCache.get("P1001");

3. 策略模式

interface PaymentStrategy {void pay(BigDecimal amount);
}class PaymentProcessor {private PaymentStrategy strategy;public void setStrategy(PaymentStrategy strategy) {this.strategy = strategy;}public void processPayment(BigDecimal amount) {strategy.pay(amount);}
}// 使用
PaymentProcessor processor = new PaymentProcessor();// 信用卡支付
processor.setStrategy(amount -> System.out.println("Paying " + amount + " via Credit Card"));
processor.processPayment(new BigDecimal("100.00"));// 支付寶支付
processor.setStrategy(amount -> System.out.println("Paying " + amount + " via Alipay"));
processor.processPayment(new BigDecimal("200.00"));

九、性能考慮

1. Lambda vs 匿名類

初始化性能：Lambda首次調用稍慢，后續調用更快
內存占用：Lambda通常占用更少內存
最佳實踐：在熱點代碼中避免頻繁創建Lambda

2. 方法引用優化

// 較慢 - 每次創建新Lambda
list.stream().map(x -> x.toString()).collect(Collectors.toList());// 更快 - 使用方法引用
list.stream().map(Object::toString).collect(Collectors.toList());

3. 并行流注意事項

數據量小（<1000元素）時順序流更快
確保操作是無狀態的
避免共享可變狀態

十、常見問題與陷阱

1. 變量修改

int sum = 0;
numbers.forEach(n -> {sum += n; // 編譯錯誤 - 不能修改捕獲的變量
});// 正確方式
int[] sumHolder = {0};
numbers.forEach(n -> sumHolder[0] += n);

2. this關鍵字

public class LambdaThis {private String value = "Enclosing";public void doWork() {Runnable r = () -> {System.out.println(this.value); // 輸出"Enclosing"};r.run();}
}

3. 重載問題

interface Adder {int add(int a, int b);
}interface SmartAdder {int add(double a, double b);
}class Calculator {void calculate(Adder adder) { /* ... */ }void calculate(SmartAdder adder) { /* ... */ }
}// 調用時會產生歧義
// calculator.calculate((x, y) -> x + y); // 編譯錯誤

十一、Java 8+ Lambda增強

1. Java 8 - 基本Lambda支持

引入函數式接口
方法引用
Stream API

2. Java 11 - 局部變量語法

var list = List.of("a", "b", "c");
list.forEach((var s) -> System.out.println(s));

3. Java 17 - 密封接口

sealed interface MathOperation permits Add, Subtract {int operate(int a, int b);
}final class Add implements MathOperation {public int operate(int a, int b) { return a + b; }
}final class Subtract implements MathOperation {public int operate(int a, int b) { return a - b; }
}// 使用
MathOperation add = (a, b) -> a + b;