Java Lambda 表达式全面详解

[一、Lambda 表达式基础](#一、Lambda 表达式基础)
- [1、什么是 Lambda 表达式](#1、什么是 Lambda 表达式)
- 2、基本语法
[二、Lambda 表达式的演变](#二、Lambda 表达式的演变)
- [1、匿名内部类 → Lambda](#1、匿名内部类 → Lambda)
- [2、各种形式的 Lambda](#2、各种形式的 Lambda)
三、函数式接口
- 1、什么是函数式接口
- [2、Java 内置的常用函数式接口](#2、Java 内置的常用函数式接口)
- - [1. Runnable - "执行一个动作"](#1. Runnable - "执行一个动作")
  - [2. Consumer<T> - "消费一个数据"](#2. Consumer<T> - "消费一个数据")
  - [3. Supplier<T> - "提供一个数据"](#3. Supplier<T> - "提供一个数据")
  - [4. Function<T, R> - "转换数据"](#4. Function<T, R> - "转换数据")
  - [5. Predicate<T> - "判断条件"](#5. Predicate<T> - "判断条件")
四、方法引用
- 1、方法引用的四种形式
- 2、方法引用示例
[五、Stream API 与 Lambda](#五、Stream API 与 Lambda)
- [1、Stream 基础操作](#1、Stream 基础操作)
- [2、常用 Stream 操作](#2、常用 Stream 操作)
六、在集合操作中的应用
- [1、List 操作](#1、List 操作)
- [2、Map 操作](#2、Map 操作)
[七、在 MyBatis-Plus 中的应用](#七、在 MyBatis-Plus 中的应用)
- 1、LambdaQueryWrapper
- 2、复杂条件构建

一、Lambda 表达式基础

1、什么是 Lambda 表达式

Lambda 表达式是 Java 8 引入的函数式编程特性，用于简化匿名内部类的写法。

Lambda 表达式本质上是一个匿名函数（没有名字的函数）。你可以把它理解为一小段可以传递的、即用即写的代码。

它的主要目的是为了简化代码，尤其是在需要使用匿名内部类的场景下，能让代码变得非常简洁、清晰。

2、基本语法

java 复制代码

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

二、Lambda 表达式的演变

1、匿名内部类 → Lambda

java 复制代码

// 传统匿名内部类
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

// Lambda 表达式
Runnable runnable = () -> System.out.println("Hello World");

2、各种形式的 Lambda

java 复制代码

// 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 表达式的类型。

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

1. Runnable - "执行一个动作"

作用：只做事，不要参数，不返回结果

java 复制代码

// 定义：无参无返回值
Runnable r = () -> System.out.println("Running");

// 使用场景：线程任务、简单的代码块执行
r.run(); // 输出 "Running"

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

// 相当于：执行一段代码块
() -> {
    System.out.println("第一件事");
    System.out.println("第二件事");
}

2. Consumer - "消费一个数据"

作用：吃进一个数据，消化掉（处理），不吐出来（不返回）

java 复制代码

// 定义：消费一个参数，无返回值
Consumer<String> consumer = s -> System.out.println(s);

// 使用：接受数据并处理
consumer.accept("Hello World"); // 输出 "Hello World"

// 实际例子
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println("你好，" + name));
// 输出：
// 你好，Alice
// 你好，Bob  
// 你好，Charlie

// 相当于：处理接收到的数据
(数据) -> {
    // 处理这个数据
    // 但不返回任何结果
}

3. Supplier - "提供一个数据"

作用：不吃饭（不要参数），只吐奶（返回值）

java 复制代码

// 定义：无参数，返回一个值
Supplier<String> supplier = () -> "Hello";

// 使用：获取数据
String result = supplier.get(); // result = "Hello"

// 实际例子
Supplier<Double> randomSupplier = () -> Math.random();
Supplier<LocalDateTime> timeSupplier = () -> LocalDateTime.now();

System.out.println(randomSupplier.get()); // 输出随机数，如 0.12345
System.out.println(timeSupplier.get());   // 输出当前时间

// 相当于：一个数据工厂
() -> {
    return 产生的数据;
}

4. Function<T, R> - "转换数据"

作用：吃进T类型，吐出R类型（数据转换）

java 复制代码

// 定义：接受T参数，返回R结果
Function<String, Integer> function = s -> s.length();

// 使用：数据转换
int length = function.apply("Hello"); // length = 5

// 实际例子
Function<String, String> toUpperCase = s -> s.toUpperCase();
Function<Integer, String> intToHex = i -> Integer.toHexString(i);

System.out.println(toUpperCase.apply("hello")); // 输出 "HELLO"
System.out.println(intToHex.apply(255));        // 输出 "ff"

// 相当于：数据加工厂
(输入数据) -> {
    return 加工后的数据;
}

5. Predicate - "判断条件"

作用：吃进数据，回答"是"或"否"

java 复制代码

// 定义：接受T参数，返回boolean
Predicate<String> predicate = s -> s.isEmpty();

// 使用：条件判断
boolean result = predicate.test("");    // result = true
boolean result2 = predicate.test("Hi"); // result2 = false

// 实际例子
Predicate<String> isLongWord = s -> s.length() > 5;
Predicate<Integer> isEven = n -> n % 2 == 0;

List<String> words = Arrays.asList("apple", "banana", "cat", "elephant");
words.stream()
     .filter(isLongWord)  // 过滤出长度>5的单词
     .forEach(System.out::println);
// 输出：banana, elephant

// 相当于：条件检查器
(数据) -> {
    return 数据是否符合条件;
}

四、方法引用

1、方法引用的四种形式

java 复制代码

// 1. 静态方法引用
Function<String, Integer> parser = Integer::parseInt;

// 2. 实例方法引用
String str = "Hello";
Supplier<Integer> lengthSupplier = str::length;

// 3. 任意对象的实例方法引用
Function<String, String> upperCase = String::toUpperCase;

// 4. 构造方法引用
Supplier<List<String>> listSupplier = ArrayList::new;

2、方法引用示例

java 复制代码

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

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

// 方法引用
names.forEach(System.out::println);

// 静态方法引用
List<Integer> numbers = Arrays.asList(1, 2, 3);
numbers.stream()
       .map(String::valueOf)  // 静态方法引用
       .forEach(System.out::println);

五、Stream API 与 Lambda

1、Stream 基础操作

java 复制代码

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// 过滤
List<String> result = names.stream()
    .filter(name -> name.length() > 3)      // Predicate
    .map(String::toUpperCase)               // Function
    .sorted()                               // Comparator
    .collect(Collectors.toList());          // Collector

2、常用 Stream 操作

java 复制代码

List<Integer> 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<String, List<Person>> peopleByCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));  // 方法引用

六、在集合操作中的应用

1、List 操作

java 复制代码

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

// 遍历
list.forEach(item -> System.out.println(item));

// 排序
list.sort((a, b) -> a.compareTo(b));
list.sort(String::compareTo);  // 方法引用

// 过滤
List<String> filtered = list.stream()
    .filter(s -> s.startsWith("A"))
    .collect(Collectors.toList());

2、Map 操作

java 复制代码

Map<String, Integer> 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<String, String> nameLength = map.entrySet().stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey,                   // 键
        entry -> String.valueOf(entry.getValue())  // 值
    ));

七、在 MyBatis-Plus 中的应用

1、LambdaQueryWrapper

java 复制代码

// 实体类属性引用
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "张三")           // 方法引用
      .gt(User::getAge, 18)                // Lambda
      .like(User::getEmail, "@gmail.com");

// 等价于：WHERE name = '张三' AND age > 18 AND email LIKE '%@gmail.com%'

2、复杂条件构建

java 复制代码

LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();

// 条件分组
wrapper.and(w -> w
    .eq(User::getStatus, 1)
    .or()
    .eq(User::getStatus, 2)
).or(w -> w
    .gt(User::getAge, 60)
    .lt(User::getAge, 18)
);

// 等价于：WHERE (status = 1 OR status = 2) OR (age > 60 OR age < 18)

Java Lambda 表达式全面详解

目录

一、Lambda 表达式基础

1、什么是 Lambda 表达式

2、基本语法

二、Lambda 表达式的演变

1、 匿名内部类 → Lambda

2、各种形式的 Lambda

三、函数式接口

1、什么是函数式接口

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

1. Runnable - "执行一个动作"

2. Consumer - "消费一个数据"

3. Supplier - "提供一个数据"

4. Function<T, R> - "转换数据"

5. Predicate - "判断条件"

四、方法引用

1、方法引用的四种形式

2、方法引用示例

五、Stream API 与 Lambda

1、Stream 基础操作

2、常用 Stream 操作

六、在集合操作中的应用

1、List 操作

2、Map 操作

七、在 MyBatis-Plus 中的应用

1、LambdaQueryWrapper

2、复杂条件构建

1、匿名内部类 → Lambda