Stream
Stream 是 Java 用来描述筛选、转换和聚合过程的数据流水线。调用 filter、map 时,程序只是建立处理阶段,不会执行传入的处理函数;调用 toList()、count() 这类终止操作时,才开始求值。终止操作需要什么结果,决定了哪些阶段和元素需要处理。
理解惰性求值,才能解释为什么 findFirst 可以提前停止、peek 里的打印可能不出现,以及无限流加了 limit 为什么仍可能无法结束。面试中推演 Stream 代码时,要沿着数据源、中间操作和终止操作,判断结果在什么时候已经确定。
1. 面试核心
先记住这几条,再读正文- 流水线由数据源、中间操作和终止操作组成,中间操作只记录规则,终止操作才触发求值。卡 · 流水线结构
- 串行执行时,筛选与映射可以逐元素衔接,不必先生成完整的中间集合;
sorted、distinct等有状态操作则要缓存元素或记住见过的值。 - 短路操作可以在结果确定后停止读取,但需要完整输入的排序会挡住后面的
limit。无限流先排序再限量,不能因此结束。卡 · 空流与无限流的终止边界 - 一个 Stream 只能消费一次;
Files.lines这类持有文件的流要用 try-with-resources 关闭。 - 实现可以跳过不影响结果的计算,比如数据源大小已知时
count()可以不执行peek,所以必要的业务动作不能放在peek里。
2. 流水线结构
一条 Stream 流水线由三部分组成:
- 数据源提供元素,可以是集合、数组、文件或生成函数。
- 中间操作描述怎样筛选或转换元素,例如
filter、map和sorted。它们返回一个新的 Stream,所以可以一个接一个地串起来。 - 终止操作触发计算,产生结果或执行动作,例如
toList、collect、reduce和findFirst。它返回的不再是 Stream,流水线到这里结束。
List<String> names = users.stream()
.filter(User::active)
.map(User::displayName)
.toList();
names 里是活跃用户的显示名。users.stream() 并不会复制一份用户列表,它只是记下「从 users 开始读」。
内部迭代是把遍历过程交给框架,调用方只描述怎样处理元素。普通 for 循环由代码显式推进,Stream 则在满足执行模式和顺序约定的前提下安排遍历,因此可以合并处理阶段、短路结束,或者并行计算。
3. 惰性求值
惰性求值是指把计算推迟到真正需要结果的时候再做。调用中间操作时,Stream 只保存传进来的函数,并不执行它们。所以下面这段代码什么都不会打印:
Stream<String> pipeline = users.stream()
.filter(user -> {
System.out.println("filter " + user.id());
return user.active();
})
.map(User::displayName);
filter 和 map 各返回一个代表新阶段的 Stream,但还没有读取任何用户。直到调用 toList(),需要算出最终列表了,用户才开始进入流水线:
List<String> names = pipeline.toList();
在这条串行流水线里,每个用户经过 filter 时会打印 ID,只有活跃用户才进入 map,最后得到显示名列表。这里 toList() 需要收集全部结果,所以会读完 users;如果终止操作只需要第一个结果,就可能提前停止。
3.1 元素的处理顺序
串行流水线中,相邻的 filter、map 可以逐元素衔接:一个用户通过筛选后,立即映射成显示名,再处理下一个用户,不需要先建一份中间列表。以下面的代码为例:
Optional<String> first = users.stream()
.filter(User::active)
.map(User::displayName)
.findFirst();
第一个用户进入 filter,如果不活跃就被丢掉,接着读第二个;如果活跃,就立刻进入 map 取显示名,再交给 findFirst。findFirst 拿到第一个结果后就通知上游停止,后面的用户根本不会被读取。整个过程没有构造任何「所有活跃用户」的临时列表。
这种衔接省去了完整的中间集合,但不代表 Stream 一定比循环快。排序、去重等操作还需要额外的状态,其中有些会要求先读完输入。
4. 无状态操作与有状态操作
无状态操作处理一个元素时,不需要记住之前处理过哪些元素。下面这些操作都属于这一类,传入的函数也应该遵守无状态要求:
filter根据条件决定是否保留当前元素。map将当前元素转换为一个结果。flatMap将当前元素转换为一个流,再展开其中的元素。peek在元素经过时执行观察动作。
有状态操作则要记住之前处理过的内容,或者等更多输入到齐:
distinct要记住已经出现过的值,才能判断当前元素是不是重复。sorted要拿到全部输入才能确定谁排第一(数据源已声明按自然顺序排序时,自然排序可以跳过)。limit、skip要数已经过了多少个元素;在有序并行流里,还要知道每个元素在全局的位置。
List<String> topNames = users.stream()
.filter(User::active)
.map(User::displayName)
.sorted()
.limit(10)
.toList();
这段代码先筛选活跃用户,再按显示名排序,最后取前 10 个。sorted 要拿到全部待排序的显示名,才能把排序结果交给 limit。因此,limit(10) 只限制最终结果的数量,并没有把排序的输入限制为 10 项;前面的 filter 才减少了需要排序的数据。
有状态不等于一定要读完输入。串行 distinct 记住已经出现过的值,遇到新值就可以向下游传递;sorted 需要完整输入,两者对短路的影响不同。
distinct() 用 equals 判断重复。数组没有重写 equals,比较的是对象身份,所以两个分别创建、内容相同的数组仍会作为两个元素保留。
4.1 短路操作
短路操作是结果确定后就能停止读取后续元素的操作。比如 anyMatch 只要找到一个匹配的元素,就可以返回 true,后面的元素看不看都不影响结果。各个短路操作停下来的条件不同:
anyMatch找到匹配元素即可返回 true,allMatch找到不匹配元素即可返回 false。noneMatch找到匹配元素即可返回 false。findFirst和findAny找到符合各自顺序要求的结果即可返回。limit是短路中间操作,限制后续阶段最多接收多少元素。
短路让处理无限流成为可能。下面这个双参数的 Stream.iterate 会不断生成元素,需要一个实际能够到达的结束条件:
List<Integer> powers = Stream.iterate(1, value -> value * 2)
.limit(10)
.toList();
结果是 1、2、4 一直到 512,共 10 个整数。limit(10) 收到第 10 个元素后就停止向上游取值。删掉它,数据源不会自行结束,toList() 持续收集元素,最终可能耗尽内存。
5. 一次性消费
一个 Stream 只能消费一次。终止操作执行后,需要另一个结果时应创建新的流水线,不能复用已消费的 Stream:
Stream<User> activeUsers = users.stream().filter(User::active);
long count = activeUsers.count();
// List<User> result = activeUsers.toList();
// 运行时抛出 IllegalStateException
count() 正常返回,但如果取消注释再调用 toList(),会抛出 IllegalStateException(提示 stream has already been operated upon or closed)。原因是 Stream 不是集合,它更像一次遍历过程:遍历到哪了、有没有短路、文件读到了哪里,都记在它身上,用过一次就没法保证回到起点。需要算两次,就从可以重复读取的数据源创建两条流水线:
Supplier<Stream<User>> activeUsers =
() -> users.stream().filter(User::active);
long count = activeUsers.get().count();
List<User> result = activeUsers.get().toList();
Supplier 每次 get() 都创建一个新的 Stream,计数和收集各遍历一次 users。注意这是两次独立的遍历,如果 users 在两次之间被修改了,count 和 result.size() 可能对不上。
5.1 I/O 数据源关闭
集合上的 Stream 不占用外部资源,用完不关也没关系。Files.lines 返回的 Stream 不一样,它背后持有一个打开的文件,终止操作执行完也不会自动关闭。所以读文件的流水线要放进 try-with-resources:
try (Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) {
long nonBlankLines = lines.filter(line -> !line.isBlank()).count();
}
这段代码统计非空白行,离开 try 块时关闭 Stream 持有的文件。不显式关闭,文件句柄就可能持续占用,积累后可能导致「too many open files」。
6. map、flatMap 与归约
选 map 还是 flatMap,看一个输入产生一个结果还是一组结果。map 是一对一,比如把用户转换成 ID:
List<Long> ids = users.stream()
.map(User::id)
.toList();
ids 里是每个用户的 ID。但一个用户可能有多个角色,想得到所有用户的全部角色,就要把每个用户的角色列表「摊平」成一条流。flatMap 要求映射函数返回一个 Stream,再把这些小流依次展开、接成一条:
List<String> roles = users.stream()
.flatMap(user -> user.roles().stream())
.distinct()
.toList();
roles 包含所有用户的角色,distinct() 去掉了重复的。看类型最清楚:假设 user.roles() 返回 List<String>,map(User::roles) 得到的是 Stream<List<String>>,每个元素是一整个列表;flatMap 得到的是 Stream<String>,每个元素是一个角色字符串,distinct() 才能按角色去重。
归约是把多个元素合成一个结果,求和就是一种归约。数值流有专门的 sum():
int total = orders.stream()
.mapToInt(Order::quantity)
.sum();
mapToInt 把订单数量转成基本类型的 IntStream,sum() 直接对 int 求和,不用为每个数量创建 Integer 对象。求和、计数、最值都有这样的专门方法,优先用它们。
更一般的归约有两种:合成一个不可变的值用 reduce,往可变容器里累积用 collect,区别见 Collector。
7. 副作用
副作用是指流水线里的函数除了返回结果,还修改了外部对象。下面的写法把显示名逐个放进外部列表:
List<String> names = new ArrayList<>();
users.stream()
.filter(User::active)
.map(User::displayName)
.forEach(names::add);
串行时它能得到正确结果,但正确性依赖「只有一个线程在调用 names::add」。哪天有人把 stream() 改成 parallelStream(),多个线程就会同时修改同一个 ArrayList,元素可能丢失,甚至抛出异常。直接让终止操作产出结果,就没有这个隐患:
List<String> names = users.stream()
.filter(User::active)
.map(User::displayName)
.toList();
串行还是并行,toList() 都会自己安排各部分结果的合并,调用方不用管理共享列表。
peek 可以执行打印日志这类观察动作,但不能承载必须发生的业务修改。短路可能让部分元素不经过它,实现也可以跳过不影响结果的调用,后面的 count() 示例展示了这种情况。写数据库、发消息等动作,可以在终止操作得到结果后显式执行,分别处理失败和重试。
8. 适用边界
Stream 适合方向明确的数据转换链,比如先筛选、再映射、最后分组或聚合。判断要不要用 Stream,可以先看能不能用一个动词说清每个阶段在做什么。遇到下面这些情况,普通循环通常更好维护:
- 每一步包含多处分支和提前返回。
- 处理过程需要频繁修改多个外部状态。
- 异常恢复与重试逻辑比数据转换更重要。
- 调试时必须观察细粒度的状态变化。
选哪种写法,看的是副作用、异常处理和可读性,而不是哪个行数更少。
对性能敏感时,再检查下面几项:
- 数据源是否容易遍历或拆分。
sorted、distinct等有状态操作放在什么位置。- 是否因装箱产生大量临时对象。
- 短路操作能否实际提前结束。
- 普通循环、串行 Stream 和并行 Stream 的基准结果有何差异。
9. 空流与无限流的终止边界
推演流水线的结果时,有两个边界容易出错:输入为空的时候,以及上游永远有下一项的时候。
空流的匹配结果取决于有没有满足条件或违反条件的元素:
anyMatch返回 false,因为没有任何元素满足条件。allMatch返回 true,因为没有元素违反条件。noneMatch返回 true,因为没有元素满足条件。- 无初值的
reduce和findFirst返回空Optional,表示缺少结果。
空流上的匹配操作不会调用判断函数,也叫谓词。有元素的流也不一定需要遍历:只要能直接确定结果,实现就可以省掉无关计算。
boolean all = Stream.<Integer>empty().allMatch(n -> n > 0); // true
long count = Stream.of(1, 2, 3).peek(System.out::println).count();
// count 为 3;实现可直接使用已知大小,跳过 peek。
第一行输入为空,结果是 true。第二行的数据源 Stream.of(1, 2, 3) 大小已知,中间只有 peek,不会改变元素个数,所以实现可以直接返回 3,peek 里的打印一次也不执行(JDK 9 起的实现会这样做)。
无限流能否结束,要看上游能不能把足够的元素交给短路操作。例如,对一个没有声明已按自然顺序排序的无限生成流,先调用 sorted() 再调用 limit(10):排序需要完整输入,却永远等不到输入结束,下游也拿不到第一个元素。反过来先取十项再排序,排序面对的就是有限输入,可以完成。limit 的位置改变了它能够截断的范围。
10. 常见问题
10.1 Stream 会修改源集合或其中的元素吗?
filter、map 不会自行修改源集合,但传入的函数可以修改其中的对象。例如,在 map 里调用 user.setName(...),修改的仍是 users 引用的那个用户。
Stream 还要求处理函数遵守不干扰(non-interference)约定:对于不支持并发修改的数据源,遍历期间不能在函数里修改源数据。例如,遍历普通 ArrayList 时又向其中增删元素,可能导致 ConcurrentModificationException 或错误结果。
10.2 findFirst 与 findAny 有什么区别?
findFirst 返回按遇到顺序(数据源约定的顺序,比如 List 的下标顺序)排在最前面的元素,findAny 可以返回任意一个。串行时两者通常拿到同一个元素;区别在并行时,findAny 可以直接用最先找到的结果,findFirst 却要等排在前面的分区都确认没有匹配。业务不关心具体是哪一个时,用 findAny。
10.3 Stream.toList() 返回的列表可以修改吗?
不可以。Stream.toList()(Java 16 起)返回不可修改的列表,调用 add 或 remove 会抛出 UnsupportedOperationException。
需要可修改列表时,可用 collect(Collectors.toCollection(ArrayList::new)) 指定容器,详见 Collector。
10.4 为什么 peek 有时没有执行?
因为 peek 只对实际经过它的元素执行。三种情况会让它不执行:没有终止操作,流水线根本没跑;短路提前结束,后面的元素没有进来;实现发现不需要遍历,比如前面 count() 直接用了已知大小。所以必须执行的业务动作不要放在 peek 里。
11. 面试题卡片
12. 参考资料
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明