Java Lambda表达式使用指南

Mozi2025-03-142025-08-05

一、Lambda 表达式的基础

1. 什么是 Lambda？

Lambda 表达式是 Java 8 引入的一种 匿名函数（没有名称的函数），用于简化 函数式接口（Functional
Interface）的实现。它的核心目标是让代码更简洁，尤其是在处理函数式编程和集合操作时。

2. 为什么需要 Lambda？

替代匿名内部类：传统方式实现接口需要大量样板代码。
函数式编程：支持将函数作为参数传递，或作为返回值。
代码简洁：用更少的代码表达相同的逻辑。

二、Lambda 的语法详解

1. 基本语法结构

1	// (参数列表)->{代码体 }

参数列表：与接口中抽象方法的参数一致。
箭头符号 ->：分隔参数和 Lambda 主体。
代码体：可以是单行代码，也可以是多行代码块。

2. 简化规则

场景	简化写法	原始写法
参数类型可推断	`(a, b) -> a + b`	`(int a, int b) -> { return a + b; }`
单个参数	`x -> x * x`	`(x) -> { return x * x; }`
无返回值的单行代码	`s -> System.out.println(s)`	`s -> { System.out.println(s); }`
单行代码有返回值	`(a, b) -> a.compareTo(b)`	`(a, b) -> { return a.compareTo(b); }`

三、函数式接口(Functional Interface)

1. 定义

函数式接口是 有且仅有一个抽象方法 的接口（允许有默认方法），可以用 @FunctionalInterface 注解标记（非强制，但推荐用于编译检查）。

2. 常见内置函数式接口

Java 8 在 java.util.function 包中预定义了四大核心函数式接口：

接口	方法	用途
`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 是否满足条件

其他扩展接口（如 BiFunction, UnaryOperator 等）也基于这四大核心。

3.基本使用

3.1、Supplier 生产者

无输入，有输出，用于生成或提供数据

// 示例1：生成随机数
//    Supplier<Double> randSuppliers = () -> Math.random();
Supplier<Double> randomSupplier = Math::random;
System.out.println(randomSupplier.get()); //0.47469178469864004

// 示例2：获取当前时间
Supplier<LocalDateTime> timeSupplier = LocalDateTime::now;
System.out.println(timeSupplier.get()); // 2025-03-17T15:26:43.893508100

// 配合 Optional 使用
Optional<String> empty = Optional.empty();
String value = empty.orElseGet(()-> "default");
System.out.println(value); // default

3.2、Consumer 消费者

有输入，无输出，用于消费数据

// 示例1：打印字符串
//Consumer<String> printConsumer = s -> System.out.println(s);
Consumer<String> printConsumer = System.out::println;
printConsumer.accept("hello");

// 示例2：修改对象状态
List<String> list = new ArrayList<>();
Consumer<String> addToList = list::add;
addToList.accept("java");  // 列表添加元素

// 链式调用 andThen
Consumer<String> c1 = s -> System.out.print("姓名: ");
Consumer<String> c2 = s -> System.out.println(s.toUpperCase());
c1.andThen(c2).accept("tom"); // 姓名: TOM

3.3、Function<T, R> 转换器

输入 T，返回 R，用于数据转换

// 示例1：字符串转长度
Function<String, Integer> lengthFunc = String::length;
System.out.println(lengthFunc.apply("hello")); // 5

// 示例2：类型转换
Function<String, LocalDate> dateParser = s -> LocalDate.parse(s);
LocalDate date = dateParser.apply("2022-10-01");

// 链式组合 compose 和 andThen
Function<Integer, Integer> multiply = x -> x * 2;
Function<Integer, Integer> add = x -> x + 3;
Function<Integer, Integer> calc = multiply.andThen(add);
System.out.println(calc.apply(5));  // (5*2)+3=13

3.4、Predicate 断言

判断条件是否成立，返回布尔值

// 示例1：判断字符串长度
Predicate<String> lengthPredicate = s -> s.length() > 5;
System.out.println(lengthPredicate.test("hello")); // false

// 示例2：组合多个条件
Predicate<Integer> even = n -> n % 2 == 0;
Predicate<Integer> greater10 = n -> n > 10;
System.out.println(even.and(greater10).test(14)); // true

// 集合过滤
List<String> words = Arrays.asList("java", "Python", "C++");
List<String> longWords = words.stream().filter(s -> s.length() > 3).collect(Collectors.toList());
for (String longWord : longWords) {
  System.out.print(longWord + " "); // java Python
}

四、Lambda 的实际应用

1. 替代匿名内部类

传统方式需要显式实现接口，而 Lambda 直接简化：

// 传统方式：实现 Runnable 接口
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

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

2. 集合操作与 Stream API

结合 Stream API，Lambda 可以高效处理集合：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 过滤偶数并平方
List<Integer> result = numbers.stream()
    .filter(n -> n % 2 == 0)     // Predicate
    .map(n -> n * n)             // Function
    .collect(Collectors.toList()); // 收集为列表

System.out.println(result); // 输出 [4, 16]

3. 自定义函数式接口

定义自己的函数式接口，实现灵活逻辑：

@FunctionalInterface
interface StringProcessor {
    String process(String input);
}

// 使用 Lambda 实现
StringProcessor toUpper = s -> s.toUpperCase();
System.out.println(toUpper.process("hello")); // 输出 "HELLO"

五、Lambda 的底层原理

1. Lambda 的实现机制

Java 编译器会将 Lambda 表达式转换为：

一个 静态方法（包含 Lambda 的代码逻辑）。
一个 invokedynamic 指令，动态绑定到目标函数式接口。

例如，以下 Lambda：

1	Function<Integer, Integer> square = x -> x * x;

会被编译为类似：

1
2
3

private static Integer lambda$0(Integer x) {
    return x * x;
}

2. 闭包与变量捕获

Lambda 可以捕获外部的 final 或 effectively final 变量

1
2
3

int base = 10;
Function<Integer, Integer> adder = x -> x + base; // base 必须是 final 或事实 final
// base = 20; // 若取消注释，会导致编译错误

为什么限制为 final？

保证 Lambda 在不同线程中访问变量时，变量的值不会意外改变，避免并发问题。

六、Lambda 的高级用法

1. 方法引用（Method Reference）

静态方法引用

实例方法引用

特定类型的方法引用

构造方法引用

2. 异常处理

Lambda 中抛出异常时，需在函数式接口方法声明中抛出，或在 Lambda 内部捕获：

// 方式1：接口方法声明抛出异常
@FunctionalInterface
interface FileReader {
    String read(File file) throws IOException;
}

FileReader reader = file -> new String(Files.readAllBytes(file.toPath()));

// 方式2：在 Lambda 内部捕获异常
Consumer<File> safeReader = file -> {
    try {
        String content = new String(Files.readAllBytes(file.toPath()));
        System.out.println(content);
    } catch (IOException e) {
        e.printStackTrace();
    }
};

七、Lambda 的注意事项

避免过度简化：复杂逻辑建议拆分为方法，保持代码可读性。
性能考量：Lambda 在大多数场景下性能与匿名类相当，但在极端性能敏感场景需测试。
调试困难：Lambda 的堆栈跟踪可能不如传统方法清晰。

八、完整示例

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

public class LambdaDemo {
    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java", "Python", "C++", "JavaScript", "Ruby");

        // 使用 Predicate 过滤以 "J" 开头的语言
        Predicate<String> startsWithJ = lang -> lang.startsWith("J");

        // 过滤并打印
        languages.stream()
            .filter(startsWithJ)
            .forEach(System.out::println); // 输出 Java, JavaScript
    }
}