需求:从订单列表里挑出金额大于 100 的,取它们的金额,求和。老写法三层 for 加一个计数器,五分钟写完,五个月后没人敢改。Stream 把它变成一条声明式流水线:说清「要什么」,不说「怎么循环」。
double total = orders.stream() // ① 水源:集合变成流
.filter(o -> o.amount() > 100) // ② 中间操作:过滤
.mapToDouble(Order::amount) // ② 映射:订单变金额
.sum(); // ③ 终点操作:求和收工
工厂传送带的画面:水源 → 几道工序(中间操作)→ 装箱出货(终点操作)。每个中间操作返回新流,可以一路点下去;终点操作一出,整条线开动,结果落袋。
中间操作(返回流,可链式):
filter(Predicate):留符合条件的map(Function):逐个变形(订单→金额)distinct() / sorted():去重 / 排序limit(n) / skip(n):取前 n 个 / 跳过 n 个peek(Consumer):中途看一眼(调试用)终点操作(触发执行,出结果):
collect(...):装进集合(最常用)forEach / count / sum:遍历 / 计数 / 求和anyMatch / allMatch:有没有 / 是不是全findFirst / reduce:找第一个 / 逐个归并中间操作只是「登记工序」,没有终点操作,一个元素都不会被处理:
orders.stream()
.filter(o -> o.amount() > 100); // 没有终点:一行都没执行
好处是整条线可以统筹优化:filter 先筛掉大半,后面的 map 少干活。也埋着坑——漏写终点操作,程序「看起来跑了」其实什么都没发生。
// 装回 List / 拼 Join
List<String> names = orders.stream()
.map(Order::buyer)
.collect(Collectors.toList());
// 分组:一行为订单按买家分桶,得到 Map<买家, List<订单>>
Map<String, List<Order>> byBuyer = orders.stream()
.collect(Collectors.groupingBy(Order::buyer));
// 下钻统计:每个买家的总金额
Map<String, Double> sumBy = orders.stream()
.collect(Collectors.groupingBy(Order::buyer,
Collectors.summingDouble(Order::amount)));
groupingBy 是宝藏:过去手写「遍历、判空桶、放进去」的十行,现在一行。词频统计、按状态分组报表、按日期归档,全是它的舞台。
mapToDouble/mapToInt 切过去,避免 Integer 装箱拆箱的白损,还白拿 sum、average、maxparallelStream():多核齐开。听很美,慎用——无状态操作才安全,里面有共享变量或 IO 就会互相踩(7 章并发篇见分晓)。默认串行,压测说话
// 老写法:取出金额>100的买家名,去重,排序
Set<String> set = new TreeSet<>();
for (Order o : orders) {
if (o.amount() > 100) set.add(o.buyer());
}
// Stream 写法
Set<String> set = orders.stream()
.filter(o -> o.amount() > 100)
.map(Order::buyer)
.collect(Collectors.toCollection(TreeSet::new));
行数没省多少,但语义一行一个动作,读代码变成读清单。
List<List<String>> nested = List.of(List.of("a", "b"), List.of("c"));
List<String> flat = nested.stream()
.flatMap(List::stream)
.collect(Collectors.toList()); // [a, b, c]
map 是一对一变形,flatMap 是一对多再摊平:每个元素变出一个小集合,最后全铺成一层。经典场景:订单列表取全部订单的商品明细——每单多个商品,flatMap 一步摊平;句子拆词统计也是它,每句话 split 成词再铺开。名字里的 flat,就是「压平」。
除了集合的 stream(),还有几个水源:Stream.of(1, 2, 3) 直接列举;Arrays.stream(arr) 从数组进;Files.lines(path) 文件一行行进(4.4 见过);Stream.generate 和 iterate 造无限流,必须配 limit 用。水源不同,工序完全通用——filter、map、collect 对谁都是同一套。这正是「流水线」抽象的威力:数据从哪来不重要,处理长什么样才重要。
Map<String, Long> freq = Files.lines(p)
.flatMap(line -> Arrays.stream(line.split(" ")))
.collect(Collectors.groupingBy(w -> w, Collectors.counting()));
对着老写法看价值:for 套 for、split、判空桶、加减,七八行三层缩进;流水线一条直线,每行一个动作。更值钱的是改需求:加一条「只统计长度大于 2 的词」,流水线中间插个 filter 就完;老代码要在嵌套深处找对位置小心动刀。可维护性的差距就是这样拉开的——改动成本越低,代码活得越久。
中间操作惰性执行,数据流到哪一步变成什么样了怎么看?peek 就是流水线中段的玻璃窗:
orders.stream()
.filter(o -> o.amount() > 100)
.peek(o -> System.out.println("过滤后:" + o))
.map(Order::buyer)
.collect(Collectors.toList());
它中途偷看一眼,不碰数据本身。定位就是调试专用:调完就删,业务逻辑别写在这里,留在生产代码里的 peek 是垃圾。
工具不是信仰,三类场景回到 for 循环:循环体要复杂跳转(break、continue 混着 return,流水线表达不了「中途撤退」);遍历中要改一大片外部状态;性能极端敏感的热路径。判断标准始终只有一个:哪版代码三个月后一眼看懂。团队 Stream 水平参差时适度保守,也是工程判断——代码是写给团队看的,不是炫技给评审团的。
流不是免费午餐:每个中间操作都是一次方法调用加一层包装,几十个元素的小数据量上,普通 for 反而更快——JIT 优化和缓存友好都站在 for 那边。流的赢面在中大数据量加表达力:上百条元素、三道工序起步,流水线的可读性红利才回本。所以业务代码优先流,性能敏感的热路径先 for 后流,用数据说话。也别拿「性能」当拒绝流的借口——多数业务的瓶颈在数据库和网络 IO,不在内存循环。
读别人的流水线,诀窍是「一行只问一件事」:filter 行问留什么,map 行问变成什么,collect 行问装成什么。三问下来,整条流水线的意图就清楚了。写的时候反过来自查:哪一行干了两个动作(map 里又过滤又转换),拆开;哪里的 Lambda 参数名是清一色的 s 和 o,改成有业务含义的名字。流水线的可读性一半在结构,另一半就省在这些小事上。
Stream.generate(...) 不加 limit 的 count 直接跑飞Stream 是「水源→中间操作→终点」的流水线:中间操作惰性登记、终点一触即发,collect 出货(groupingBy 一行顶十行);默认串行,数字流省装箱,并行流压测再上。