Java Stream流：从核心概念到实战调优的完整指南

1. 项目概述：为什么每个Java开发者都绕不开Stream流？

如果你写过Java，尤其是Java 8及以后的版本，那你肯定听说过或者用过Stream。但很多时候，我们只是把它当作一个“更酷”的循环语法糖，list.stream().filter().map().collect()一套连招打完，感觉代码是简洁了，但心里可能还是有点虚：这玩意儿到底是怎么工作的？性能怎么样？什么时候该用，什么时候不该用？我见过不少项目，为了用Stream而用Stream，结果写出了比传统循环更难读、更难调试的代码，甚至因为一个不当的parallel()调用导致线上服务性能雪崩。

我自己也是从“一脸懵”到“离不开”走过来的。最初觉得这概念太抽象，不如for循环实在。直到有一次处理一个几百万行的日志文件，需要做过滤、转换和聚合，用传统的for循环加临时集合，代码写了上百行，内存占用还高，调试起来更是头疼。硬着头皮改用Stream API配合Files.lines()，代码缩减到十几行，逻辑清晰得像在写需求文档，而且因为Stream的延迟执行特性，内存压力小了很多。那次之后，我才真正体会到Stream不是语法糖，而是一种全新的、声明式的集合数据处理范式。

简单来说，Java Stream流是Java 8引入的一个核心新特性，它允许你以声明式的方式处理数据集合（比如List、Set、Map或数组）。你只需要告诉程序“做什么”（比如过滤出所有成年用户、计算平均工资），而不是“怎么做”（遍历、判断、累加）。这带来的好处是代码更简洁、更易读，并且为并行计算提供了近乎零成本的抽象。无论是处理内存中的集合，还是操作I/O流（如文件、网络），Stream都能提供一套统一、强大的API。对于面临高并发、大数据量处理的现代Java应用来说，熟练掌握Stream是提升开发效率和程序性能的必修课。

2. Stream核心概念与设计哲学拆解

要玩转Stream，不能只死记硬背几个方法，得先理解它的设计思想。这就像学武功，招式是表象，心法是根本。

2.1 流与集合的本质区别

这是最容易混淆的点。集合（Collection）和流（Stream）虽然都存储元素，但它们的关注点完全不同。

集合（Collection）是一个内存中的数据结构，它持有所有数据。你操作集合，就是在直接操作内存中的数据本身。比如，你从一个List里移除一个元素，这个List的状态就立刻改变了。集合的核心是“数据存储”和“即时计算”。

流（Stream）则更像一个“数据管道”或“计算配方”。它本身不存储数据（或者说，它存储的是对数据源的引用），它定义了一系列对数据的操作（过滤、映射、排序等）。最关键的是，这些操作是延迟执行的。只有当你触发一个“终端操作”（比如collect或forEach）时，整个操作链才会开始执行，并且数据会像水流一样，逐个通过这个管道被处理。

举个例子：你有一个装满水果的篮子（集合）。你想找出所有苹果。用集合的方式，你需要新建一个空篮子，然后遍历原篮子，看到苹果就拿出来放进新篮子。用流的方式，你则是定义了一个“过滤器”，这个过滤器只让苹果通过。只有当你真正需要一个装苹果的新篮子（触发终端操作）时，过滤器才开始工作，苹果才被一个个筛选出来。

这种延迟执行的特性，是Stream实现高效处理（尤其是大数据和链式操作）的基石。它意味着中间操作（如filter,map）可以无限叠加而不会立即产生计算开销，直到终端操作被调用，所有操作才会被优化、合并，然后一次性执行。

2.2 流的操作分类：中间操作与终端操作

所有Stream的操作被清晰地分为两类，理解这一点是正确使用Stream的关键。

中间操作（Intermediate Operations）：这类操作总是返回一个新的Stream，允许你进行链式调用。它们是“懒惰”的，不会立即执行任何数据处理，只是将一个操作添加到流水线的描述中。常见的中间操作有：

• filter(Predicate)：过滤，保留满足条件的元素。
• map(Function)：映射，将元素转换成另一种形式。
• sorted()/sorted(Comparator)：排序。
• distinct()：去重。
• limit(long n)：限制元素数量。
• skip(long n)：跳过前n个元素。

终端操作（Terminal Operations）：这类操作会触发流水线的执行，并产生一个结果或副作用。执行后，该流就被“消耗”了，不能再被使用。常见的终端操作有：

• forEach(Consumer)：遍历每个元素，通常用于产生副作用（如打印）。
• collect(Collector)：将流中的元素累积成一个结果容器，如List、Set、Map或字符串。这是最常用、最强大的终端操作。
• reduce(...)：将流中的元素反复结合，得到一个值（如求和、求最大值）。
• count()：计数。
• anyMatch()/allMatch()/noneMatch()：检查流中元素是否匹配给定条件。
• findFirst()/findAny()：查找元素。

实操心得：一个常见的错误是在调用了终端操作（如forEach）后，还想继续对流进行操作。记住一个简单的原则：一旦调用了collect、forEach、count等方法，这个流就“关闭”了。如果你需要复用处理逻辑，应该保存的是中间操作的“配方”（即方法引用或Lambda表达式），而不是流本身。

2.3 并行流：一把需要谨慎使用的双刃剑

Stream API 最吸引人的特性之一就是能轻松实现并行计算。你只需要将.stream()换成.parallelStream()，或者在流中间调用.parallel()方法，框架就会尝试将工作负载分配到多个CPU核心上执行。

原理是，Stream的并行实现基于Fork/Join框架。它会将数据源分成多个子块（分治），在不同的线程上处理这些子块，最后将结果合并。这对于数据量大、且每个元素处理成本较高的任务（如复杂的计算、I/O等待）可能带来显著的性能提升。

但是，并行流不是银弹，滥用会导致严重问题：

1. 开销问题：线程的创建、销毁、任务拆分与结果合并都有开销。如果数据量很小（比如只有几十个元素），或者每个元素处理非常简单，并行化的开销可能会远远超过其带来的收益，导致程序更慢。
2. 数据源与状态问题：并行流要求数据源易于拆分（如ArrayList），而LinkedList这类结构拆分成本高。更重要的是，在并行操作中，必须确保传递给流操作的函数（Lambda）是无状态且不干扰数据源的。如果Lambda修改了共享状态（如外部变量），会导致竞态条件，结果不可预测。
3. 顺序依赖：有些操作本质上是顺序的，比如limit、skip，在并行流中使用它们可能会比顺序流更慢，甚至导致错误结果。

踩坑记录：我曾在一个需要根据特定规则对列表排序并取前10个的场景中，不小心加上了.parallel()。结果发现，在数据量大的时候，返回的前10个结果每次运行都不完全一样。这是因为并行排序和limit的组合在底层实现上存在不确定性。对于有严格顺序要求的操作，一定要慎用并行流。

使用建议：不要默认使用并行流。先写出正确、清晰的顺序流代码。只有在性能分析（Profiling）明确指示该处是CPU密集型瓶颈，且数据量足够大时，才考虑尝试使用并行流，并且务必进行严格的测试和性能对比。

3. 核心API深度解析与实战技巧

了解了心法，我们来拆解招式。Stream API方法众多，但掌握核心的几个，就能解决80%的问题。

3.1 流的创建：不止于集合

创建流是第一步，方式非常灵活。

1. 从集合创建：最常用的方式。

List<String> list = Arrays.asList("a", "b", "c"); Stream<String> streamFromList = list.stream(); // 顺序流 Stream<String> parallelStreamFromList = list.parallelStream(); // 并行流

2. 从数组创建：

String[] array = {"a", "b", "c"}; Stream<String> streamFromArray = Arrays.stream(array); // 或者使用Stream.of，它内部调用的也是Arrays.stream Stream<String> streamFromArray2 = Stream.of("a", "b", "c");

3. 使用Stream.generate()或Stream.iterate()创建无限流：

// 生成一个无限随机数流 Stream<Double> infiniteRandom = Stream.generate(Math::random).limit(10); // 用limit截断 // 生成一个无限序列：1, 3, 5, 7... Stream<Integer> oddNumbers = Stream.iterate(1, n -> n + 2).limit(5);

无限流必须配合limit等短路操作使用，否则程序不会终止。

4. 从文件等I/O资源创建：

// 读取文件所有行成为流，自动关闭资源，强烈推荐！ try (Stream<String> lines = Files.lines(Paths.get("data.txt"))) { lines.filter(line -> !line.startsWith("#")) .forEach(System.out::println); }

使用try-with-resources确保流（底层是I/O资源）被正确关闭，这是很多人容易忽略但至关重要的一点。

3.2 关键中间操作：filter,map,flatMap

filter：过滤的核心。参数是一个Predicate（返回boolean的函数）。只保留使谓词为true的元素。

List<User> adults = users.stream() .filter(user -> user.getAge() >= 18) // Lambda表达式 .collect(Collectors.toList()); // 使用方法引用，如果User有isAdult()方法 List<User> adults2 = users.stream() .filter(User::isAdult) .collect(Collectors.toList());

map：转换的核心。参数是一个Function（接受一个参数，返回一个结果）。它将流中的每个元素映射成另一个元素。

// 提取所有用户的名字 List<String> names = users.stream() .map(User::getName) .collect(Collectors.toList()); // 将字符串转换成大写 List<String> upperCaseNames = names.stream() .map(String::toUpperCase) .collect(Collectors.toList());

flatMap：这是新手最容易困惑，但功能极其强大的操作。它用于处理“流中流”的场景。 参数是一个Function，但这个函数返回的不是一个值，而是一个Stream。flatMap的作用是将每个元素产生的流“拍平”连接成一个流。

经典场景：你有一个List<List<String>>，想得到所有字符串。

List<List<String>> listOfLists = Arrays.asList( Arrays.asList("a", "b"), Arrays.asList("c", "d", "e") ); // 如果只用map，得到的是Stream<Stream<String>> // 使用flatMap，将内部的小流连接成一个大流 List<String> allStrings = listOfLists.stream() .flatMap(List::stream) // Collection::stream 方法引用 .collect(Collectors.toList()); // 结果：["a", "b", "c", "d", "e"]

另一个常见场景是处理包含多个属性的对象，比如一个订单有多个订单项。

// 获取所有订单中的所有商品名称 List<String> allProductNames = orders.stream() .flatMap(order -> order.getItems().stream()) // 将每个订单的items流拍平 .map(Item::getProductName) .collect(Collectors.toList());

3.3 强大的终端操作：collect与Collectors

collect是终端操作中的瑞士军刀，Collectors则是配套的工具箱。它们能将流规约成各种你需要的形态。

1. 归集到集合：

List<String> list = stream.collect(Collectors.toList()); Set<String> set = stream.collect(Collectors.toSet()); // 指定具体集合类型，如ArrayList ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));

2. 归集到Map： 这是面试高频考点，也是日常开发难点。

// 1. 最简单的：toMap，指定key和value的提取函数 // 假设User有id和name属性 Map<Long, String> idToNameMap = users.stream() .collect(Collectors.toMap(User::getId, User::getName)); // 危险！如果key重复，会抛出IllegalStateException

// 2. 处理key冲突：提供合并函数（merge function） // 假设按城市分组，但城市可能重复，我们取第一个遇到的名字（或进行其他合并逻辑） Map<String, String> cityToFirstNameMap = users.stream() .collect(Collectors.toMap( User::getCity, User::getName, (name1, name2) -> name1 // 如果城市重复，保留第一个名字 ));

// 3. 指定具体的Map实现类 Map<String, User> treeMap = users.stream() .collect(Collectors.toMap( User::getName, Function.identity(), (u1, u2) -> u1, TreeMap::new // 指定为TreeMap，会按键排序 ));

3. 分组：groupingBy分组是数据分析的利器。

// 按城市分组用户 Map<String, List<User>> usersByCity = users.stream() .collect(Collectors.groupingBy(User::getCity)); // 结果：{"Beijing": [User1, User2], "Shanghai": [User3...]} // 下游收集器：分组后还可以对每组的元素做进一步操作 // 例如，按城市分组，并计算每组的平均年龄 Map<String, Double> avgAgeByCity = users.stream() .collect(Collectors.groupingBy( User::getCity, Collectors.averagingInt(User::getAge) // 下游收集器 )); // 多级分组：先按城市，再按年龄段 Map<String, Map<String, List<User>>> usersByCityAndAgeGroup = users.stream() .collect(Collectors.groupingBy( User::getCity, Collectors.groupingBy(user -> { int age = user.getAge(); if (age < 18) return "未成年"; else if (age < 60) return "成年"; else return "老年"; }) ));

4. 分区：partitioningBy分区是分组的一种特例，分组的依据是一个布尔条件，结果Map只有两个键：true和false。

// 将用户分成成年和未成年两组 Map<Boolean, List<User>> partitionedUsers = users.stream() .collect(Collectors.partitioningBy(user -> user.getAge() >= 18)); // 结果：{true=[...], false=[...]}

5. 汇总统计：

// 计算年龄的统计信息：计数、总和、最小值、平均值、最大值 IntSummaryStatistics ageStatistics = users.stream() .collect(Collectors.summarizingInt(User::getAge)); System.out.println("平均年龄: " + ageStatistics.getAverage()); System.out.println("最大年龄: " + ageStatistics.getMax()); // 连接字符串 String allNames = users.stream() .map(User::getName) .collect(Collectors.joining(", ", "[", "]")); // 结果：[张三, 李四, 王五]

3.4 其他重要操作：reduce,sorted,distinct

reduce：归约操作，将流中的元素反复结合，得到一个值。它是collect的更底层抽象，collect可以看作是一种可变的reduce。

// 求年龄总和 Optional<Integer> totalAge = users.stream() .map(User::getAge) .reduce(Integer::sum); // 等同于 (a, b) -> a + b // 提供一个初始值，避免返回Optional Integer totalAgeWithIdentity = users.stream() .map(User::getAge) .reduce(0, Integer::sum); // 初始值为0

reduce非常灵活，可以实现各种累积逻辑，但通常collect和Collectors已经封装了大部分常用场景，代码更简洁。

sorted：排序。可以自然排序，也可以传入自定义比较器。

// 自然排序（按年龄，User需实现Comparable） List<User> sortedByAge = users.stream() .sorted() .collect(Collectors.toList()); // 自定义比较器 List<User> sortedByName = users.stream() .sorted(Comparator.comparing(User::getName)) .collect(Collectors.toList()); // 多重排序：先按城市排，城市相同再按年龄排 List<User> sortedByCityThenAge = users.stream() .sorted(Comparator.comparing(User::getCity) .thenComparingInt(User::getAge)) .collect(Collectors.toList());

注意事项：对于有序流（如从List创建的流），sorted是一个有状态的中断操作，它需要将所有元素缓冲起来才能排序。对于大数据流，这可能消耗大量内存。对于并行流，sorted使用了一种稳定的、自适应的归并排序。

distinct：去重。基于元素的equals()和hashCode()方法。

List<String> uniqueNames = names.stream() .distinct() .collect(Collectors.toList());

对于自定义对象，确保正确重写了equals()和hashCode()方法，否则distinct可能无法按预期工作。

4. 性能调优、常见陷阱与最佳实践

会用Stream写代码只是第一步，写出高效、健壮、易维护的Stream代码才是高手。

4.1 性能考量与调优策略

1. 避免在链式调用中重复创建流：这是一个隐蔽的性能杀手。

   // 错误示范：对同一个列表创建了两次流 List<String> names = dataList.stream().map(Data::getName).collect(toList()); List<Integer> ages = dataList.stream().map(Data::getAge).collect(toList()); // 正确做法：只创建一次流，如果需要不同的结果，考虑用一次循环或使用一个收集器收集多个结果（复杂场景）。 // 或者，如果业务允许，合并操作： Map<String, Integer> nameAgeMap = dataList.stream() .collect(toMap(Data::getName, Data::getAge));

2. 注意装箱/拆箱开销：Stream API有专门的原始类型特化流：IntStream,LongStream,DoubleStream。当处理大量整数、长整数或浮点数时，使用它们可以避免Integer、Long、Double的装箱和拆箱开销，提升性能并减少内存占用。

   // 低效：涉及Integer的装箱 int sum = users.stream().mapToInt(User::getAge).sum(); // 好！返回IntStream // 高效：直接使用IntStream IntStream ages = users.stream().mapToInt(User::getAge); double averageAge = ages.average().orElse(0.0);

3. 短路操作优化：有些终端操作是“短路”的，比如anyMatch,allMatch,noneMatch,findFirst,findAny。它们不需要处理整个流，一旦找到满足条件的结果就会立即停止。合理利用它们可以提高效率。

   // 检查列表中是否有年龄大于100的用户，一旦找到就停止 boolean hasCentenarian = users.stream().anyMatch(u -> u.getAge() > 100);

4. 排序与去重的代价：sorted和distinct是有状态的中断操作，它们通常需要看到所有元素后才能进行。在流处理链中，尽量把它们往后放，以减少需要处理的元素数量。

   // 不佳：先对100万个元素排序，再过滤 list.stream().sorted().filter(x -> x > 1000).limit(10)...; // 更佳：先过滤，可能只剩下几百个元素，再排序 list.stream().filter(x -> x > 1000).sorted().limit(10)...;

4.2 调试与异常处理

Stream的链式调用和延迟执行使得调试变得困难。你不能像在for循环里那样轻松地打点查看中间状态。

1. 使用peek进行调试：peek是一个中间操作，它接收一个Consumer，对流中的每个元素执行一些操作（如打印），但不会改变流本身。它主要用于调试。

   List<String> result = list.stream() .filter(s -> s.length() > 3) .peek(s -> System.out.println("After filter: " + s)) // 调试点 .map(String::toUpperCase) .peek(s -> System.out.println("After map: " + s)) // 调试点 .collect(Collectors.toList());

   警告：peek在并行流中的执行顺序是不确定的，且不要在生产代码中用它来修改状态或产生主要业务逻辑的副作用，它仅用于调试。

2. 异常处理：Lambda表达式内部如果抛出受检异常（Checked Exception），会非常麻烦，因为函数式接口（如Function,Predicate）的方法签名不抛出异常。

   // 假设这个方法会抛出IOException List<String> lines = urls.stream() .map(url -> { // 这里编译报错，需要处理IOException try { return fetchContent(url); } catch (IOException e) { throw new RuntimeException(e); // 包装成运行时异常 } }) .collect(Collectors.toList());

   常见的做法是：

   • 在Lambda内部用try-catch包装，抛出运行时异常。
   • 编写一个工具方法，将抛出受检异常的函数包装成不抛出的版本。
   • 对于复杂的流操作，有时回归传统的for循环进行错误处理会更清晰。

4.3 可读性与维护性最佳实践

1. 适度使用，避免过度链式：虽然链式调用很酷，但过长的链（比如超过5-7个操作）会严重损害可读性。考虑将中间结果提取到有意义的变量中，或者将一部分逻辑抽取成独立的方法。

   // 难以阅读的长链 Map<X, List<Y>> result = ...stream().filter(...).map(...).sorted(...).collect(...); // 改进：提取关键步骤 Stream<Y> processedStream = rawStream.filter(this::isValid) .map(this::transform); Map<X, List<Y>> groupedResult = processedStream.collect(groupingBy(...));

2. 使用方法引用提升简洁性：在合适的地方，用方法引用（Class::method）替代Lambda表达式，代码更简洁、意图更明确。

   // Lambda .map(user -> user.getName()) // 方法引用（更好） .map(User::getName)

3. 为复杂的收集器操作命名：当collect中的收集器逻辑很复杂时，将其提取到一个静态常量或工具方法中。

   // 复杂的收集器 private static final Collector<User, ?, Map<String, Double>> AVG_AGE_BY_CITY_COLLECTOR = Collectors.groupingBy(User::getCity, Collectors.averagingInt(User::getAge)); // 使用 Map<String, Double> result = users.stream().collect(AVG_AGE_BY_CITY_COLLECTOR);

4. 明确空值（Optional）的处理：Stream API中很多操作（如findFirst,max,min）返回Optional。永远不要直接调用Optional.get()，而应该使用orElse(),orElseGet(),orElseThrow()等安全方法。

   // 危险！如果流为空，会抛出NoSuchElementException User oldest = users.stream().max(Comparator.comparing(User::getAge)).get(); // 安全 User oldestSafe = users.stream() .max(Comparator.comparing(User::getAge)) .orElse(null); // 或提供一个默认用户 // 或者如果认为必须有值，可以明确抛出业务异常 User oldestOrThrow = users.stream() .max(Comparator.comparing(User::getAge)) .orElseThrow(() -> new BusinessException("用户列表为空"));

5. 实战案例：从需求到Stream代码的完整推演

理论说再多，不如看一个完整的例子。假设我们有一个电商订单列表，需要完成以下分析：

1. 找出最近一个月内所有已支付的订单。
2. 将这些订单按用户ID分组。
3. 对于每个用户，计算其总消费金额和平均订单金额。
4. 筛选出总消费金额大于1000元的“重要用户”。
5. 按总消费金额降序排列，并输出前10名用户的ID和总金额。

我们一步步用Stream来实现。

步骤1：定义数据模型

@Data // 使用Lombok简化代码 public class Order { private String orderId; private String userId; private LocalDateTime createTime; private BigDecimal amount; // 订单金额 private String status; // 状态，如 "PAID", "UNPAID", "CANCELLED" }

步骤2：编写Stream处理逻辑

public class OrderAnalysisService { public List<ImportantUserSummary> analyzeImportantUsers(List<Order> allOrders) { // 1. 定义一个月前的时间点 LocalDateTime oneMonthAgo = LocalDateTime.now().minusMonths(1); // 2. 使用Stream进行处理 Map<String, ImportantUserSummary> result = allOrders.stream() // 过滤：最近一个月且已支付 .filter(order -> order.getCreateTime().isAfter(oneMonthAgo)) .filter(order -> "PAID".equals(order.getStatus())) // 分组：按用户ID .collect(Collectors.groupingBy( Order::getUserId, // 下游收集器：自定义一个收集器来聚合用户数据 Collector.of( () -> new UserAccumulator(), // 供应器：创建累加器 (acc, order) -> acc.accept(order), // 累加器：处理每个订单 (acc1, acc2) -> acc1.combine(acc2), // 组合器（用于并行流） acc -> acc.toSummary() // 完成器：生成最终结果 ) )); // 此时得到 Map<String, ImportantUserSummary> // 3. 筛选重要用户（总金额>1000），排序，取前10 return result.values().stream() .filter(summary -> summary.getTotalAmount().compareTo(new BigDecimal("1000")) > 0) .sorted(Comparator.comparing(ImportantUserSummary::getTotalAmount).reversed()) .limit(10) .collect(Collectors.toList()); } // 自定义累加器，用于在分组时聚合一个用户的所有订单数据 private static class UserAccumulator { private String userId; private BigDecimal totalAmount = BigDecimal.ZERO; private int orderCount = 0; public void accept(Order order) { if (this.userId == null) { this.userId = order.getUserId(); } this.totalAmount = this.totalAmount.add(order.getAmount()); this.orderCount++; } public UserAccumulator combine(UserAccumulator other) { // 用于并行流合并 this.totalAmount = this.totalAmount.add(other.totalAmount); this.orderCount += other.orderCount; return this; } public ImportantUserSummary toSummary() { BigDecimal avgAmount = orderCount == 0 ? BigDecimal.ZERO : totalAmount.divide(new BigDecimal(orderCount), 2, RoundingMode.HALF_UP); return new ImportantUserSummary(userId, totalAmount, avgAmount, orderCount); } } // 结果摘要类 @Data @AllArgsConstructor public static class ImportantUserSummary { private String userId; private BigDecimal totalAmount; private BigDecimal averageAmount; private int orderCount; } }

步骤3：代码解读与优化上面的例子展示了相对复杂的收集逻辑。实际上，对于这个需求，我们可以用Collectors内置方法更简洁地实现第2步的分组聚合，无需自定义累加器：

Map<String, ImportantUserSummary> result = allOrders.stream() .filter(order -> order.getCreateTime().isAfter(oneMonthAgo)) .filter(order -> "PAID".equals(order.getStatus())) .collect(Collectors.groupingBy( Order::getUserId, Collectors.collectingAndThen( Collectors.toList(), // 先将用户的所有订单收集到List orderList -> { BigDecimal total = orderList.stream() .map(Order::getAmount) .reduce(BigDecimal.ZERO, BigDecimal::add); BigDecimal avg = total.divide( new BigDecimal(orderList.size()), 2, RoundingMode.HALF_UP); return new ImportantUserSummary( orderList.get(0).getUserId(), total, avg, orderList.size() ); } ) ));

这种写法利用了collectingAndThen，先收集列表，再对列表进行转换计算。两种方式都可以，自定义累加器在数据量极大时可能性能稍好（避免中间列表），而collectingAndThen的写法更函数式、更紧凑。在实际开发中，应根据复杂度和性能要求进行权衡。

这个案例涵盖了过滤、分组、复杂聚合、排序、限制等核心操作，是一个比较全面的Stream实战。通过这样的练习，你会对Stream的声明式威力有更深的理解——我们只关心“要什么”（过滤条件、分组键、聚合逻辑），而不是“怎么循环、怎么存临时变量”。代码的意图变得非常清晰。