Lambda 表达式是 Java 8 引入的最重要的特性之一，它标志着 Java 开始支持函数式编程范式。Lambda 表达式提供了一种清晰而简洁的方式来表示一个方法接口，并且极大地简化了代码编写。

一、Lambda 表达式基础

1. 什么是 Lambda 表达式？

Lambda 表达式是一个​​匿名函数​​，即没有名称的函数。它允许你将函数作为方法参数传递，或者将代码本身作为数据处理。

2. 基本语法

(parameters) -> expression

或

(parameters) -> { statements; }

3. 演变过程：从匿名类到 Lambda

// Java 8 之前：使用匿名内部类
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

// Java 8：使用 Lambda 表达式
Runnable r2 = () -> System.out.println("Hello World");

二、函数式接口 (Functional Interface)

1. 什么是函数式接口？

函数式接口是​​只有一个抽象方法​​的接口。Lambda 表达式需要依赖函数式接口来实现。

// 自定义函数式接口
@FunctionalInterface // 注解可选，但推荐使用（编译器会检查）
interface MyFunction {
    int operate(int a, int b);
    // 只能有一个抽象方法
    
    // 但可以有默认方法和静态方法
    default void printResult(int result) {
        System.out.println("Result: " + result);
    }
}

2. Java 内置的核心函数式接口

接口	参数	返回类型	描述	示例
Predicate<T>	T	boolean	断言，条件判断	x -> x > 5
Function<T,R>	T	R	转换函数，输入T返回R	s -> s.length()
Consumer<T>	T	void	消费者，消费数据无返回	x -> System.out.println(x)
Supplier<T>	无	T	供应商，提供数据	() -> new Random().nextInt()
UnaryOperator<T>	T	T	一元操作，输入输出同类型	x -> x * 2
BinaryOperator<T>	(T, T)	T	二元操作，输入输出同类型	(a, b) -> a + b

3. 使用示例

// Predicate 示例：过滤数字
Predicate<Integer> isEven = n -> n % 2 == 0;
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                  .filter(isEven)
                                  .collect(Collectors.toList()); // [2, 4]

// Function 示例：字符串转换
Function<String, Integer> stringToLength = s -> s.length();
List<String> words = Arrays.asList("hello", "world", "java");
List<Integer> lengths = words.stream()
                            .map(stringToLength)
                            .collect(Collectors.toList()); // [5, 5, 4]

// Consumer 示例：打印元素
Consumer<String> printer = s -> System.out.println(s);
words.forEach(printer); // 打印每个单词

// Supplier 示例：生成随机数
Supplier<Integer> randomSupplier = () -> new Random().nextInt(100);
System.out.println(randomSupplier.get()); // 输出随机数

三、方法引用 (Method Reference)

方法引用是 Lambda 表达式的简写形式，用于直接引用已有的方法。

1. 四种方法引用类型

类型	语法	等效 Lambda
静态方法引用	ClassName::staticMethod	(args) -> ClassName.staticMethod(args)
实例方法引用	instance::method	(args) -> instance.method(args)
任意对象的实例方法	ClassName::instanceMethod	(obj, args) -> obj.instanceMethod(args)
构造方法引用	ClassName::new	(args) -> new ClassName(args)

2. 使用示例

// 静态方法引用
Function<String, Integer> parser = Integer::parseInt;
Integer num = parser.apply("123"); // 123

// 实例方法引用
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println); // 等效于: s -> System.out.println(s)

// 任意对象的实例方法引用
List<String> strings = Arrays.asList("hello", "world", "java");
List<String> upperCase = strings.stream()
                               .map(String::toUpperCase) // 等效于: s -> s.toUpperCase()
                               .collect(Collectors.toList());

// 构造方法引用
Supplier<List<String>> listSupplier = ArrayList::new;
List<String> newList = listSupplier.get(); // 创建新的ArrayList

四、Lambda 表达式实战应用

1. 集合操作与 Stream API

List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 35)
);

// 过滤、映射、收集
List<String> names = people.stream()
                          .filter(p -> p.getAge() > 25)      // 过滤年龄>25的人
                          .map(Person::getName)              // 提取姓名
                          .map(String::toUpperCase)          // 转为大写
                          .collect(Collectors.toList());     // 收集到列表

// 分组
Map<Integer, List<Person>> peopleByAge = people.stream()
                                              .collect(Collectors.groupingBy(Person::getAge));

// 排序
List<Person> sorted = people.stream()
                           .sorted((p1, p2) -> p1.getAge() - p2.getAge())
                           .collect(Collectors.toList());

2. 线程创建

// 传统方式
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in thread");
    }
}).start();

// Lambda 方式
new Thread(() -> System.out.println("Running in thread")).start();

3. 事件处理

// Swing 事件监听
JButton button = new JButton("Click me");
button.addActionListener(e -> System.out.println("Button clicked!"));

// JavaFX 事件处理
button.setOnAction(event -> System.out.println("Button clicked!"));

4. 可选操作 (Optional)

Optional<String> optional = Optional.ofNullable(getPossibleNullValue());

// 传统 null 检查
if (optional.isPresent()) {
    String value = optional.get();
    System.out.println(value);
}

// Lambda 方式
optional.ifPresent(value -> System.out.println(value));
// 或使用方法引用
optional.ifPresent(System.out::println);

五、Lambda 表达式高级特性

1. 变量捕获 (Variable Capture)

Lambda 表达式可以捕获外部作用域的变量，但这些变量必须是 ​​final 或 effectively final​​（即事实上的 final，赋值后不再修改）。

int fixedValue = 10;
// fixedValue = 20; // 如果取消注释，会导致编译错误

Function<Integer, Integer> multiplier = x -> x * fixedValue; // 可以捕获

// 在Lambda内部修改外部变量也是不允许的
List<Integer> results = new ArrayList<>();
numbers.forEach(n -> {
    // results = new ArrayList<>(); // 错误：不能修改引用
    results.add(n * 2); // 正确：可以修改引用指向对象的内容
});

2. 闭包 (Closure) 行为

Lambda 表达式会记住它创建时的变量值，即使这些变量后来发生了变化。

Function<Integer, Integer>[] functions = new Function[10];
for (int i = 0; i < 10; i++) {
    // int capture = i; // 解决方法：使用局部变量捕获当前值
    functions[i] = x -> x + i; // 所有函数都会使用最终的i值(10)
}

// 所有函数都会返回 x + 10
System.out.println(functions[0].apply(5)); // 输出15，而不是5

3. 组合函数

Java 8 允许将多个函数组合在一起形成更复杂的操作。

Function<Integer, Integer> multiplyBy2 = x -> x * 2;
Function<Integer, Integer> add3 = x -> x + 3;

// 组合函数：先乘2再加3
Function<Integer, Integer> multiplyAndAdd = multiplyBy2.andThen(add3);
System.out.println(multiplyAndAdd.apply(5)); // (5 * 2) + 3 = 13

// 组合函数：先加3再乘2
Function<Integer, Integer> addAndMultiply = multiplyBy2.compose(add3);
System.out.println(addAndMultiply.apply(5)); // (5 + 3) * 2 = 16

// Predicate 组合
Predicate<Integer> isEven = n -> n % 2 == 0;
Predicate<Integer> isGreaterThan5 = n -> n > 5;

Predicate<Integer> isEvenAndGreaterThan5 = isEven.and(isGreaterThan5);
System.out.println(isEvenAndGreaterThan5.test(6)); // true
System.out.println(isEvenAndGreaterThan5.test(4)); // false

六、性能考虑与最佳实践

1. 性能特点

• ​​首次调用成本​​：Lambda 首次调用会有一些初始化开销
• ​​后续调用​​：与普通方法调用性能相当
• ​​JVM 优化​​：JVM 会对频繁使用的 Lambda 进行内联优化

2. 最佳实践

// 1. 保持Lambda简短（理想情况下1-3行）
Function<String, Integer> calculate = s -> {
    // 复杂逻辑应该提取到单独的方法中
    return complexCalculation(s);
};

// 2. 使用方法引用代替简单Lambda
// 不要这样：
Function<String, Integer> lengthFunc = s -> s.length();
// 应该这样：
Function<String, Integer> lengthFunc = String::length;

// 3. 避免副作用（保持函数纯度）
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> results = new ArrayList<>();

// 不良实践：有副作用
numbers.stream()
      .filter(n -> n % 2 == 0)
      .forEach(n -> results.add(n)); // 修改外部状态

// 良好实践：无副作用
List<Integer> evenNumbers = numbers.stream()
                                 .filter(n -> n % 2 == 0)
                                 .collect(Collectors.toList());

// 4. 注意变量捕获规则
int external = 10;
// 在Lambda中不要修改外部变量
IntStream.range(0, 5).forEach(i -> {
    // external += i; // 编译错误
});

// 5. 为复杂Lambda添加类型注解，增强可读性
BinaryOperator<Long> adder = (Long x, Long y) -> x + y;

3. 调试技巧

Lambda 表达式在调试时可能不太直观，可以：

• 将复杂 Lambda 分解为多个方法引用
• 使用 IDE 的调试功能查看 Lambda 的调用栈
• 在必要时使用传统的匿名类以便于调试

七、Lambda 与匿名类的比较

特性	Lambda 表达式	匿名类
​​语法​​	简洁	冗长
​​this 关键字​​	指向外部类	指向匿名类本身
​​编译结果​​	invokedynamic 字节码指令	生成单独的类文件
​​性能​​	通常更好（JVM优化）	较差
​​变量捕获​​	只能捕获 final 或 effectively final 变量	同样限制
​​方法定义​​	不能定义新方法	可以定义新方法

总结

Lambda 表达式是 Java 函数式编程的核心，它通过简洁的语法和强大的表达能力，极大地改善了 Java 代码的可读性和编写效率。关键要点：

1. ​​依赖函数式接口​​：Lambda 需要与函数式接口配合使用
2. ​​方法引用更简洁​​：尽可能使用方法引用代替简单 Lambda
3. ​​保持纯净无副作用​​：编写纯函数式的 Lambda 表达式
4. ​​注意变量捕获规则​​：只能捕获 final 或 effectively final 变量
5. ​​合理使用 Stream API​​：Lambda 与 Stream API 结合使用效果最佳

掌握 Lambda 表达式不仅能让代码更简洁，还能帮助你更好地理解现代 Java 开发中的函数式编程思想。