Java Lambda

Java Lambda 表达式是 Java 8 引入的一项重要特性，用于简化函数式编程的实现。它允许开发者以更简洁的方式编写代码，特别是在处理集合操作、事件监听或函数式接口时。

什么是 Lambda 表达式？

Lambda 表达式是一种匿名函数，它提供了一种简洁的方式来表示函数式接口（Functional Interface）的实例。函数式接口是只包含一个抽象方法的接口，例如 Runnable、Comparator 或 Function。

Lambda 表达式的核心目的：

简化代码：减少样板代码（如匿名内部类的冗长写法）
支持函数式编程：使 Java 更适合处理函数式编程范式，例如流式操作（Stream API）

Lambda 表达式的语法

基本语法：

1	`(参数列表) -> { 方法体 }`

参数列表：可以为空，也可以包含多个参数。如果只有一个参数，可以省略括号
箭头操作符（->）：分隔参数列表和方法体
方法体：包含执行逻辑，可以是单行表达式或多行语句块。如果是单行表达式，可以省略大括号和 return 语句

语法示例

无参数：

1	`() -> System.out.println("Hello, Lambda!");`

单参数（省略括号）：
1
x -> x * x
多参数：
1
(x, y) -> x + y

多行方法体：

(x, y) -> {
    System.out.println("Processing: " + x + ", " + y);
    return x + y;
}

Lambda 表达式的工作原理

Lambda 表达式本质上是函数式接口的实现。Java 编译器会将 Lambda 表达式转换为相应的函数式接口的实例。

函数式接口

函数式接口是用 @FunctionalInterface 注解标记的接口（可选），确保接口只有一个抽象方法。

@FunctionalInterface
interface MyFunction {
    int apply(int x, int y);
}

Lambda 表达式绑定

Lambda 表达式可以赋值给函数式接口类型的变量：

1 2	`MyFunction add = (x, y) -> x + y; System.out.println(add.apply(2, 3)); // 输出：5`

编译器推断

编译器会根据上下文推断 Lambda 表达式的目标类型（即它实现的函数式接口）。例如，Collections.sort() 方法期望一个 Comparator 接口，Lambda 表达式会自动适配。

Lambda 表达式的用途

简化匿名内部类

在 Java 8 之前，匿名内部类常用于实现接口的单个方法。Lambda 表达式可以显著减少代码量。

传统匿名内部类：

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in a thread!");
    }
};

使用 Lambda 表达式：

1	`Runnable runnable = () -> System.out.println("Running in a thread!");`

Stream API

Lambda 表达式与 Java 8 的 Stream API 结合使用，极大地简化了集合操作，例如过滤、映射和归约。

示例：过滤偶数并求和

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = numbers.stream()
                .filter(n -> n % 2 == 0)  // 过滤偶数
                .mapToInt(n -> n)         // 转换为 IntStream
                .sum();
System.out.println(sum); // 输出：12（2 + 4 + 6）

事件处理

在 GUI 编程（如 JavaFX 或 Swing）中，Lambda 表达式可以简化事件监听器的实现。

1	`button.setOnAction(event -> System.out.println("Button clicked!"));`

函数式接口的标准库

Java 8 提供了 java.util.function 包，包含许多内置的函数式接口：

接口	方法签名	用途
`Predicate<T>`	`boolean test(T t)`	条件判断
`Function<T, R>`	`R apply(T t)`	将 T 转换为 R
`Consumer<T>`	`void accept(T t)`	接受 T 进行操作，无返回值
`Supplier<T>`	`T get()`	生成 T 类型的值

示例：

1 2	`Function<String, Integer> toInteger = s -> Integer.parseInt(s); System.out.println(toInteger.apply("123")); // 输出：123`

Lambda 表达式的特点

简洁性

省略了方法名、返回类型和访问修饰符，编译器会自动推断
单行表达式可以省略 return 和大括号

上下文推断

Lambda 表达式依赖上下文确定目标类型。例如，同一个 Lambda 表达式可以适配不同的函数式接口，只要签名匹配。

闭包特性

Lambda 表达式可以捕获外部变量（称为"捕获变量"），但这些变量必须是effectively final（事实最终变量），即不能在 Lambda 表达式外部被修改。

int x = 10;
Consumer<Integer> consumer = y -> System.out.println(x + y);
consumer.accept(5); // 输出：15
// x = 20; // 编译错误：x 必须是 effectively final

性能优化

Lambda 表达式在 JVM 中通过 invokedynamic 指令实现，性能优于传统的匿名内部类
每次调用 Lambda 表达式不会创建新的类文件

方法引用（Method Reference）

方法引用是 Lambda 表达式的简写形式，用于直接引用已有方法，进一步简化代码。方法引用使用 :: 操作符。

方法引用类型

静态方法引用：ClassName::staticMethod

1	`Function<String, Integer> parse = Integer::parseInt;`

实例方法引用：instance::instanceMethod

1 2	`String str = "Hello"; Supplier<Integer> length = str::length;`

特定类实例方法引用：ClassName::instanceMethod
1
Comparator<String> comparator = String::compareTo;

构造函数引用：ClassName::new

1	`Supplier<List<String>> listSupplier = ArrayList::new;`

方法引用与 Lambda 表达式的等价性

// Lambda 表达式
Function<String, Integer> lambda = s -> s.length();

// 方法引用
Function<String, Integer> methodRef = String::length;

Lambda 表达式的限制

只能实现函数式接口：Lambda 表达式只能用于实现只有一个抽象方法的接口。如果接口有多个抽象方法，需使用匿名内部类。
变量捕获限制：捕获的变量必须是 final 或 effectively final，否则编译报错。
this 引用：在 Lambda 表达式中，this 引用的是外部类的实例，而不是 Lambda 表达式本身。这与匿名内部类不同（匿名内部类的 this 指向匿名类实例）。
异常处理：如果 Lambda 表达式抛出受检异常（checked exception），需要显式处理（try-catch 或在函数式接口中声明 throws）。

最佳实践

保持简洁：Lambda 表达式应尽量简短，避免复杂的逻辑。如果方法体过长，考虑抽取为普通方法。
优先使用方法引用：如果 Lambda 表达式只是调用已有方法，优先使用方法引用，代码更简洁且可读性更高。
避免过度捕获变量：尽量减少捕获外部变量，以降低代码耦合性和潜在的错误。
注意性能：对于频繁调用的 Lambda 表达式，注意性能开销，尤其是在多线程环境中。
清晰命名函数式接口：自定义函数式接口时，使用有意义的名称，并添加 @FunctionalInterface 注解以明确意图。

综合示例

以下示例展示 Lambda 表达式、方法引用和 Stream API 的结合使用：

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 使用 Lambda 表达式过滤名字长度大于 3 的元素
        Predicate<String> lengthFilter = s -> s.length() > 3;
        names.stream()
             .filter(lengthFilter)
             .forEach(System.out::println); // 输出：Alice, Charlie, David

        // 使用方法引用排序
        names.stream()
             .sorted(String::compareTo)
             .forEach(System.out::println); // 输出：Alice, Bob, Charlie, David
    }
}

总结

Java Lambda 表达式是 Java 8 引入的强大特性，极大地提高了代码的简洁性和可读性。它与 Stream API 和函数式接口结合，为函数式编程提供了支持。

核心要点：

语法简洁：(参数) -> 表达式 或 (参数) -> { 语句块 }
函数式接口：Lambda 表达式必须绑定到只有一个抽象方法的接口
用途广泛：简化匿名内部类、集合操作、事件处理等
方法引用：进一步简化 Lambda 表达式的写法
限制：变量捕获、异常处理等需要注意