Java Lambda 表达式作为 Java 8 引入的函数式编程特性，主要用于简化匿名内部类的编写。内容涵盖 Lambda 基本语法、从匿名内部类到 Lambda 的演变、常用函数式接口（Runnable、Consumer、Supplier、Function、Predicate）的定义与场景。此外还包含方法引用的四种形式、Stream API 与 Lambda 的结合使用、集合操作示例以及在 MyBatis-Plus 中构建动态查询条件（LambdaQueryWrapper）的实际应用案例。
Lambda 表达式是 Java 8 引入的函数式编程特性，用于简化匿名内部类的写法。 Lambda 表达式本质上是一个。你可以把它理解为一小段可以传递的、即用即写的代码。
它的主要目的是为了简化代码，尤其是在需要使用匿名内部类的场景下，能让代码变得非常简洁、清晰。
(parameters)-> expression // 或 (parameters)->{ statements;}
// 传统匿名内部类
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Hello World");
}
};
// Lambda 表达式
Runnable lambdaRunnable = () -> System.out.println("Hello World");
// 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;
};
只有一个抽象方法的接口，可以用作 Lambda 表达式的类型。
作用：只做事，不要参数，不返回结果
// 定义：无参无返回值
Runnable r = () -> System.out.println("Running");
// 使用场景：线程任务、简单的代码块执行
r.run(); // 输出 "Running"
// 实际例子
new Thread(() -> System.out.println("在新线程中运行")).start();
// 相当于：执行一段代码块
() -> {
System.out.println("第一件事");
System.out.println("第二件事");
};
作用：吃进一个数据，消化掉（处理），不吐出来（不返回）
// 定义：消费一个参数，无返回值
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));
// 相当于：处理接收到的数据
(数据) -> {
// 处理这个数据
// 但不返回任何结果
};
作用：不吃饭（不要参数），只吐奶（返回值）
// 定义：无参数，返回一个值
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 产生的数据;
};
作用：吃进 T 类型，吐出 R 类型（数据转换）
// 定义：接受 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 加工后的数据;
};
作用：吃进数据，回答'是'或'否'
// 定义：接受 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)
.forEach(System.out::println); // 输出：banana, elephant
// 相当于：条件检查器
(数据) -> {
return 数据是否符合条件;
};
// 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;
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);
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
// 过滤
List<String> result = names.stream()
.filter(name -> name.length() > 3)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());
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));
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());
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())
));
// 实体类属性引用
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "张三")
.gt(User::getAge, 18)
.like(User::getEmail, "@gmail.com");
// 等价于：WHERE name = '张三' AND age > 18 AND email LIKE '%@gmail.com%'
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)
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
暂无推荐文章，稍后可再来查看。
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online