java的lambda和stream流操作

Lambda 表达式 ≈ 匿名函数

（Lambda接口）函数式接口：传入Lambda表达作为函数式接口的参数

函数式接口 = 只能有一个抽象方法的接口
Lambda 表达式必须赋值给一个函数式接口，比如 Java 8 自带的：

接口名 作用
Function<T,R> 传入 T 类型，返回 R 类型
Consumer 传入 T 类型，无返回（只执行）
Supplier 不传参，返回 T 类型值
Predicate 传入 T 类型，返回布尔（true/false）
核心理解：
Lambda 表达式只能赋值或传入“函数式接口（Functional Interface）”类型的变量或参数。

所以当你在方法中想要传入一个 Lambda 表达式作为参数时，方法的参数类型必须是某个函数式接口类型，否则 编译器不知道这个函数的签名该怎么对照，就会报错。

🧪 例 1：使用 Function<T, R>
java
复制
编辑
public static String transform(String input, Function<String, String> transformer) {
return transformer.apply(input);
}

// 调用时传入 Lambda 表达式：
String result = transform(“java”, s -> s.toUpperCase());
System.out.println(result); // JAVA
🧪 例 2：使用 Predicate 做条件判断
public static boolean check(String str, Predicate condition) {
return condition.test(str);
}

boolean isLong = check(“hello”, s -> s.length() > 3);
🧪 例 3：使用 Consumer 执行操作
public static void greet(String name, Consumer greeter) {
greeter.accept(name);
}

greet(“Jack”, s -> System.out.println("Hello " + s));
🧪 例 4：使用 Supplier 获取值
public static String getRandom(Supplier supplier) {
return supplier.get();
}

String value = getRandom(() -> UUID.randomUUID().toString());

如果你不指定这些接口（也就是函数式接口），Lambda 就没法传入！
比如这会报错：
public void doSomething(Object handler) {
// …
}

doSomething(x -> x + 1); // ❌ 编译错误：Object 不是函数式接口

Stream流：Java 8 的 Stream API 是一个用于处理集合数据的强大工具，支持链式调用、函数式编程风格

List 是一个顺序的集合，其中的每个元素都只是一个值。在流式操作中，流传递的就是这些值。

在流中处理的是每一个对象按需处理，list（‘hai’，‘dong’）那么在流中传递处理的就是‘hai’和‘dong’

Map 是由键值对（key-value）组成的集合，需要转换为Set。这里的流传递的元素是每个 Map.Entry<K, V>（即每个键值对）。

ageMap.entrySet()
.stream()
.map(entry -> entry.getKey() + " is " + entry.getValue() + " years old.")
.forEach(System.out::println);

将集合转换为stream

.stream()

常用中间操作（Intermediate）

中间操作是链式调用的操作，它们不会立即执行，而是会“懒执行”直到遇到终结操作。

1. .filter() — 过滤
   用于从 Stream 中筛选出符合条件的元素。filter() 方法接收一个 Predicate（一个返回 boolean 的函数）。

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List result = numbers.stream()
.filter(x -> x > 3) // 只保留大于 3 的数字
.collect(Collectors.toList());
System.out.println(result); // 输出 [4, 5, 6]

2. .map() — 转换
   用于将 Stream 中的每个元素转换为其他类型或做某种操作。map() 方法接收一个 Function（一个接受一个参数并返回一个结果的函数）。

List names = Arrays.asList(“Tom”, “Jerry”, “Spike”);
List nameLengths = names.stream()
.map(String::length) // 转换每个名字为它的长度
.collect(Collectors.toList());
System.out.println(nameLengths); // 输出 [3, 5, 5]

3. .flatMap() — 打平嵌套结构
   如果元素是一个集合（比如 List 或 Set），你可以使用 flatMap 把它“打平”为一个单一的流。这个操作适用于“集合中有集合”的情况。

List<List> namesList = Arrays.asList(
Arrays.asList(“Tom”, “Jerry”),
Arrays.asList(“Spike”, “Tyke”)
);

List flattenedList = namesList.stream()
.flatMap(List::stream) // 把 List 变成一个单一的 Stream
.collect(Collectors.toList());

System.out.println(flattenedList); // 输出 [Tom, Jerry, Spike, Tyke]

4. .sorted() — 排序
   sorted() 用于对流中的元素进行排序。它可以使用默认排序或自定义排序（通过传入一个 Comparator）。

List numbers = Arrays.asList(5, 3, 8, 1, 7);
List sortedNumbers = numbers.stream()
.sorted() // 默认升序排序
.collect(Collectors.toList());
System.out.println(sortedNumbers); // 输出 [1, 3, 5, 7, 8]
自定义排序：

List names = Arrays.asList(“Tom”, “Jerry”, “Spike”);
List sortedNames = names.stream()
.sorted((a, b) -> b.compareTo(a)) // 降序排序
.collect(Collectors.toList());
System.out.println(sortedNames); // 输出 [Spike, Tom, Jerry]

5. .distinct() — 去重
   distinct() 用于去除重复元素。

List numbers = Arrays.asList(1, 2, 3, 2, 3, 4);
List distinctNumbers = numbers.stream()
.distinct() // 去除重复的元素
.collect(Collectors.toList());
System.out.println(distinctNumbers); // 输出 [1, 2, 3, 4]

6. .limit(n) — 限制前 n 个
   limit(n) 用于限制 Stream 中的元素个数。

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List limitedNumbers = numbers.stream()
.limit(3) // 只保留前 3 个元素
.collect(Collectors.toList());
System.out.println(limitedNumbers); // 输出 [1, 2, 3]

7. .skip(n) — 跳过前 n 个
   skip(n) 用于跳过 Stream 中的前 n 个元素。

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List skippedNumbers = numbers.stream()
.skip(3) // 跳过前 3 个元素
.collect(Collectors.toList());
System.out.println(skippedNumbers); // 输出 [4, 5, 6]

常用终结操作（Terminal）

终结操作会触发流的计算并最终返回一个结果，或者是将流的内容收集到一个集合中。终结操作执行时会迫使 Stream 中的中间操作开始工作。

1. .collect() — 收集（成 List、Set、Map 等）
   collect() 是一个常用的终结操作，它用于将流的元素收集到一个集合或其他容器中。

List numbers = Arrays.asList(1, 2, 3, 4, 5);
List result = numbers.stream()
.filter(x -> x > 3)
.collect(Collectors.toList()); // 收集成一个 List
System.out.println(result); // 输出 [4, 5]

2. .forEach() — 遍历
   forEach() 用于遍历流中的每个元素，并对每个元素执行给定的操作。它接收一个 Consumer 类型的参数。

List names = Arrays.asList(“Tom”, “Jerry”, “Spike”);
names.stream()
.forEach(System.out::println); // 打印每个名字

3. .count() — 计数
   count() 用于返回流中的元素数量。

List numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream()
.filter(x -> x > 3)
.count(); // 返回大于 3 的元素数量
System.out.println(count); // 输出 2

4. .reduce() — 规约（合并结果）
   reduce() 是一个强大的终结操作，可以用来将流中的元素“规约”成一个单一的结果，通常用于求和、求积等操作。

List numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b); // 求和，初始值是 0
System.out.println(sum); // 输出 15

5. .anyMatch() — 是否有任意满足条件的元素
   anyMatch() 用于检查流中是否有至少一个元素符合给定条件，返回一个 boolean 值。

List numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean result = numbers.stream()
.anyMatch(x -> x > 4); // 判断是否有元素大于 4
System.out.println(result); // 输出 true

6. .allMatch() — 是否所有元素都满足条件
   allMatch() 用于检查流中的所有元素是否都符合给定的条件，返回一个 boolean 值。

List numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean result = numbers.stream()
.allMatch(x -> x > 0); // 判断是否所有元素都大于 0
System.out.println(result); // 输出 true

7. .findFirst() — 返回第一个元素（Optional）
   findFirst() 返回流中的第一个元素。它返回一个 Optional，可以避免空指针异常。

List names = Arrays.asList(“Tom”, “Jerry”, “Spike”);
String firstName = names.stream()
.findFirst()
.orElse(“No Name”); // 如果流为空，返回 “No Name”
System.out.println(firstName); // 输出 Tom