JavaLambda表达式深度解析

一、Lambda 表达式基础

1、什么是 Lambda 表达式

说起 Ja va 8 带来的革命性变化，Lambda 表达式绝对榜上有名。它本质上是一种函数式编程特性，但别被“函数式”这个词吓到，它的核心目的其实非常朴素：简化代码，尤其是那些需要匿名内部类的繁琐写法。

你可以把它想象成一段匿名的、即用即写的代码块。它没有名字，但可以被传递和执行，这就让代码变得异常灵活和简洁。从某种意义上说，它把“行为”也变成了一种可以传递的数据。

2、基本语法

Lambda 的语法非常直观，记住两种基本形式就够了：

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

箭头（->）左边是参数列表，右边是要执行的动作。如果逻辑简单，一行表达式足矣；如果逻辑复杂，用花括号包起来，写成一个完整的代码块。

二、Lambda 表达式的演变

1、 匿名内部类 → Lambda

让我们从一个最经典的场景看起：创建线程任务。对比之下，Lambda 带来的简洁性一目了然。

// 传统匿名内部类：啰嗦，模板代码多
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};
// Lambda 表达式：干净利落，直奔主题
Runnable runnable = () -> System.out.println("Hello World");

看到了吗？那些冗余的类声明、方法重写签名统统不见了，剩下的只有最核心的逻辑。这就是 Lambda 的魅力。

2、各种形式的 Lambda

Lambda 的表达形式非常灵活，可以根据参数和返回值的不同，演变出多种写法：

// 1. 无参数，无返回值：就像执行一个简单的命令
() -> System.out.println("Hello");

// 2. 一个参数，无返回值：参数处理，括号有时可省略
(x) -> System.out.println(x);
x -> System.out.println(x);  // 更简洁

// 3. 多个参数，有返回值：类型声明也可由编译器推断
(int x, int y) -> x + y;
(x, y) -> x + y;  // 类型推断

// 4. 复杂逻辑，需要代码块：多条语句用花括号包裹，并显式返回
(x, y) -> {
    int result = x + y;
    System.out.println("结果: " + result);
    return result;
}

三、函数式接口

1、什么是函数式接口

Lambda 表达式不能单独存在，它需要一个“类型”。这个类型就是函数式接口——一个只包含一个抽象方法的接口。Lambda 表达式就是这个抽象方法的实现。可以说，函数式接口是 Lambda 的“家”。

2、Ja va 内置的常用函数式接口

Ja va 8 在 ja va.util.function 包里贴心地准备了一组常用的函数式接口，理解它们，就等于掌握了 Lambda 的绝大部分应用场景。

1. Runnable - “执行一个动作”

核心作用：只做事，不要参数，也不返回结果。典型的“默默付出型”。

// 定义：无参无返回值
Runnable r = () -> System.out.println("Running");
// 使用：直接调用 run 方法
r.run(); // 输出 "Running"

// 实际例子：启动新线程
new Thread(() -> System.out.println("在新线程中运行")).start();

// 也可以执行多行代码块
() -> {
    System.out.println("第一件事");
    System.out.println("第二件事");
}

2. Consumer - “消费一个数据”

核心作用：吃进一个数据，消化掉（处理），但不吐出来（不返回）。就像一个数据处理终端。

// 定义：消费一个参数，无返回值
Consumer consumer = s -> System.out.println(s);
// 使用：用 accept 方法“喂”数据给它
consumer.accept("Hello World"); // 输出 "Hello World"

// 实际例子：遍历集合并处理每个元素
List names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println("你好，" + name));
// 输出：
// 你好，Alice
// 你好，Bob  
// 你好，Charlie

3. Supplier - “提供一个数据”

核心作用：不吃饭（不要参数），只吐奶（返回值）。相当于一个数据工厂或生成器。

// 定义：无参数，返回一个值
Supplier supplier = () -> "Hello";
// 使用：调用 get 方法获取数据
String result = supplier.get(); // result = "Hello"

// 实际例子：生成随机数或获取当前时间
Supplier randomSupplier = () -> Math.random();
Supplier timeSupplier = () -> LocalDateTime.now();
System.out.println(randomSupplier.get()); // 输出随机数，如 0.12345
System.out.println(timeSupplier.get());   // 输出当前时间

4. Function - “转换数据”

核心作用：吃进T类型，吐出R类型。专业的数据转换器或加工厂。

// 定义：接受T参数，返回R结果
Function function = s -> s.length();
// 使用：apply 方法进行转换
int length = function.apply("Hello"); // length = 5

// 实际例子：字符串转大写，整数转十六进制
Function toUpperCase = s -> s.toUpperCase();
Function intToHex = i -> Integer.toHexString(i);
System.out.println(toUpperCase.apply("hello")); // 输出 "HELLO"
System.out.println(intToHex.apply(255));        // 输出 "ff"

5. Predicate - “判断条件”

核心作用：吃进数据，回答“是”或“否”。一个纯粹的条件检查器。

// 定义：接受T参数，返回boolean
Predicate predicate = s -> s.isEmpty();
// 使用：test 方法进行判断
boolean result = predicate.test("");    // result = true
boolean result2 = predicate.test("Hi"); // result2 = false

// 实际例子：过滤集合中的元素
Predicate isLongWord = s -> s.length() > 5;
List words = Arrays.asList("apple", "banana", "cat", "elephant");
words.stream()
     .filter(isLongWord)  // 过滤出长度>5的单词
     .forEach(System.out::println);
// 输出：banana, elephant

上图清晰地展示了这几个核心函数式接口的分工与协作关系，可以说它们是构建现代 Ja va 流式处理的基石。

四、方法引用

1、方法引用的四种形式

当 Lambda 表达式仅仅是调用一个已有方法时，代码还可以进一步简化，这就是方法引用。它使用双冒号（::）语法，让代码意图更加清晰。

// 1. 静态方法引用：引用类的静态方法
Function parser = Integer::parseInt;

// 2. 实例方法引用：引用特定对象的实例方法
String str = "Hello";
Supplier lengthSupplier = str::length;

// 3. 任意对象的实例方法引用：引用任意该类对象的实例方法
Function upperCase = String::toUpperCase;

// 4. 构造方法引用：引用类的构造器
Supplier> listSupplier = ArrayList::new;

2、方法引用示例

让我们通过对比，看看方法引用如何让代码变得更优雅：

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

// Lambda 表达式
names.forEach(name -> System.out.println(name));

// 方法引用：意图更明确，就是“打印”
names.forEach(System.out::println);

// 静态方法引用：将整数转为字符串
List numbers = Arrays.asList(1, 2, 3);
numbers.stream()
       .map(String::valueOf)  // 等价于 i -> String.valueOf(i)
       .forEach(System.out::println);

五、Stream API 与 Lambda

1、Stream 基础操作

Stream API 是 Lambda 表达式的最佳拍档，它允许你以声明式的方式处理数据集合。一个典型的流处理管道包含多个阶段：

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

// 一个完整的流处理链条：过滤 -> 转换 -> 排序 -> 收集
List result = names.stream()
    .filter(name -> name.length() > 3)      // Predicate：过滤条件
    .map(String::toUpperCase)               // Function：转换操作
    .sorted()                               // 排序
    .collect(Collectors.toList());          // 将流收集为List

2、常用 Stream 操作

通过组合不同的操作，可以轻松实现复杂的数据处理逻辑：

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 过滤偶数，平方，然后求和
int sum = numbers.stream()
    .filter(n -> n % 2 == 0)           // 过滤：只保留偶数
    .map(n -> n * n)                   // 映射：计算平方
    .reduce(0, Integer::sum);          // 归约：求和（使用方法引用）

// 分组操作：按城市对人进行分组
Map> peopleByCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));  // 关键的分组操作

六、在集合操作中的应用

1、List 操作

Lambda 让传统的集合操作焕然一新，遍历、排序、过滤都变得更加直观。

List list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

// 遍历：告别 for 循环
list.forEach(item -> System.out.println(item));

// 排序：Comparator 用 Lambda 表达，简洁无比
list.sort((a, b) -> a.compareTo(b));
list.sort(String::compareTo);  // 或者用方法引用

// 过滤：使用流快速筛选
List filtered = list.stream()
    .filter(s -> s.startsWith("A"))
    .collect(Collectors.toList());

2、Map 操作

Map 的遍历和转换也因 Lambda 而变得优雅。

Map map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 35);

// 遍历：同时获取键和值
map.forEach((name, age) -> 
    System.out.println(name + ": " + age));

// 转换：将 Map 转换为 Map
Map nameLength = map.entrySet().stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey,                   // 键保持不变（方法引用）
        entry -> String.valueOf(entry.getValue())  // 值转为字符串（Lambda）
    ));

七、在 MyBatis-Plus 中的应用

1、LambdaQueryWrapper

在持久层框架中，Lambda 表达式大放异彩，它解决了 SQL 条件编写中的“硬编码”问题，提供了编译期安全。

// 使用实体类的属性引用，避免字段名拼写错误
LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "张三")           // 方法引用，对应 name 字段
      .gt(User::getAge, 18)                // Lambda，对应 age > 18
      .like(User::getEmail, "@gmail.com"); // 对应 email LIKE '%@gmail.com%'
// 生成的SQL：WHERE name = '张三' AND age > 18 AND email LIKE '%@gmail.com%'

2、复杂条件构建

即使是复杂的嵌套条件，用 Lambda 表达也清晰易懂。

LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>();

// 构建条件分组：(status = 1 OR status = 2) OR (age > 60 OR age < 18)
wrapper.and(w -> w
    .eq(User::getStatus, 1)
    .or()
    .eq(User::getStatus, 2)
).or(w -> w
    .gt(User::getAge, 60)
    .lt(User::getAge, 18)
);

这种写法不仅安全，而且可读性极高，条件逻辑一目了然，极大提升了复杂查询的构建和维护效率。