内容总览
一、起源:集合处理中的三类摩擦
1.1 样板循环:意图被流程遮蔽
一段典型的集合处理代码长这样:
// 从订单中取出已支付订单的客户城市,去重后排序
Set<String> cities = new HashSet<>();
for (Order order : orders) {
if (order.getStatus() == Status.PAID) {
Customer customer = order.getCustomer();
if (customer != null) {
cities.add(customer.getCity());
}
}
}
List<String> result = new ArrayList<>(cities);
Collections.sort(result);
这段代码真正表达的业务意图只有一句:"已支付订单的客户城市,去重排序"。其余代码——声明临时集合、控制循环、判断空值、收集后再排序——都在描述"怎么做"。
由此产生三类摩擦:
| 摩擦 | 表现 | 后果 |
|---|---|---|
| 样板与意图混杂 | 临时变量、循环骨架、收集动作占了大半篇幅 | 阅读时需要先在脑中"模拟执行"才能看清业务条件 |
| 意图分散在多处 | 过滤条件、映射规则、去重与排序分散在循环体内外 | 修改一处规则要在整个方法里找相关行 |
| 结构重复 | "过滤 + 映射 + 收集""分组 + 统计""求和 + 计数"在同一代码库反复出现 | 相同的骨架写十几遍,每遍都可能带入不同的边界处理差异 |
同样的三类问题在"分组统计""排序取前 N""求和与平均"等场景里重复出现,说明问题不在某段代码写得不好,而在缺少一种把"数据变换"直接表达出来的写法。
1.2 把行为作为参数传递的动机
真正的诉求是:把"做什么"抽出来作为参数,让库负责"怎么做"——遍历顺序、是否并发、何时短路、如何合并,这些与业务无关的细节应由库实现一次。
Java 8 之前,唯一的手段是匿名内部类:
// Java 8 之前:用匿名内部类描述"按金额倒序"
orders.sort(new Comparator<Order>() {
@Override
public int compare(Order a, Order b) {
return Double.compare(b.getAmount(), a.getAmount());
}
});
这段代码的问题不在长度,而在语义:
- 与"比较两个订单金额"无关的语法占了大部分篇幅,真正的意图只有最后一行;
- 匿名类内部的
this指向匿名类实例,访问外围成员需要写Outer.this; - 即使行为完全相同,每次执行都会新建一个对象;
- 类型定义与使用位置分离时,读者需要来回跳转。
同一段逻辑的三种写法对比:
// 形式一:匿名内部类
orders.sort(new Comparator<Order>() {
@Override
public int compare(Order a, Order b) {
return Double.compare(b.getAmount(), a.getAmount());
}
});
// 形式二:Lambda
orders.sort((a, b) -> Double.compare(b.getAmount(), a.getAmount()));
// 形式三:方法引用(存在具名比较方法时)
orders.sort(Comparator.comparingDouble(Order::getAmount).reversed());
排序、过滤、回调、事件处理,本质上都是"把一段行为交给系统在合适的时机调用"。语言层面缺少表达这种"行为参数"的轻量写法,是 Java 8 必须解决的问题。
1.3 兼容性约束:为什么必须引入函数式接口
一个直觉上的方案是引入真正的函数类型(类似 Scala 的 Function0 至 Function22),但这条路在 Java 上走不通。
现存 API 的参数类型已经是接口:
void sort(Comparator<? super E> c);
Future<?> submit(Runnable task);
<T> T submit(Callable<T> task);
void addActionListener(ActionListener l);
如果新增一套独立的函数类型,sort、submit、addActionListener 全部无法接收新类型的值,只能修改签名——这会破坏源码兼容与二进制兼容。而 Java 的核心承诺是:JDK 1.0 编译的 class 文件至今仍能在新版本 JVM 上运行。
最终方案是把只有一个抽象方法的接口(Single Abstract Method,SAM)确立为 Lambda 的目标类型:
Runnable、Comparator、Callable这些老接口无需改动,自动获得 Lambda 写法;- Lambda 本身没有类型,它只是"实现某个 SAM 接口"的简写;
- 配合 Java 8 的默认方法,接口可以在不破坏已有实现类的前提下扩展(
Iterable.forEach、Collection.stream、Comparator.thenComparing),这些默认方法成为流式 API 的入口; - 实现层面用
invokedynamic与LambdaMetafactory在运行期生成实现,避免为每个 Lambda 生成一个独立的 class 文件。
Java 的函数式不是"引入函数类型",而是"给既有接口一种更轻的写法"。这一定位决定了后续所有设计的形状:类型推断围绕目标类型展开,方法引用是 Lambda 的简写,Stream 的每个操作都接收标准函数式接口。
范式对比与版本演进的完整脉络见 编程范式与 Java 演进;基础语法与 API 清单见 Java 完整手册 第十章。本篇只讨论机制与工程落地。
二、原理
2.1 函数式接口与 Lambda
2.1.1 SAM 的含义
函数式接口的判定标准是:接口中恰好有一个抽象方法。以下三类成员不计入:
Object中已有实现的方法(equals、hashCode、toString);default方法;static方法。
@FunctionalInterface
public interface OrderValidator {
ValidationResult validate(Order order); // 唯一的抽象方法
default OrderValidator andThen(OrderValidator next) {
return o -> {
ValidationResult r = this.validate(o);
return r.isValid() ? next.validate(o) : r;
};
}
static OrderValidator alwaysValid() {
return o -> ValidationResult.ok();
}
}
@FunctionalInterface 只做编译期检查,不加注解的 SAM 接口同样可以作为 Lambda 的目标类型。加上它的价值在于接口演化:若有人新增一个抽象方法,编译会立刻失败,而不是等到所有调用点报错。
2.1.2 内置接口及其变体
java.util.function 提供了四类基本形状与它们的变体:
| 形状 | 抽象方法 | 语义 | 二元变体 | 基本类型特化 |
|---|---|---|---|---|
Function<T,R> | R apply(T) | 转换 | BiFunction<T,U,R> | IntFunction<R>、ToIntFunction<T>、IntUnaryOperator、ToIntBiFunction<T,U> |
Consumer<T> | void accept(T) | 消费 | BiConsumer<T,U> | IntConsumer、ObjIntConsumer<T> |
Supplier<T> | T get() | 提供 | — | IntSupplier、BooleanSupplier |
Predicate<T> | boolean test(T) | 判定 | BiPredicate<T,U> | IntPredicate、ToIntFunction<T>(返回 int) |
UnaryOperator<T> | T apply(T) | 同类型一元运算 | BinaryOperator<T> | IntUnaryOperator、IntBinaryOperator |
特化接口的命名有固定规则:入参类型作前缀,返回类型作后缀,To 表示"返回该类型"。因此:
IntFunction<String> f1; // int 入参 → String
ToIntFunction<String> f2; // String 入参 → int
IntUnaryOperator f3; // int → int
IntPredicate f4; // int → boolean
特化的动机是消除装箱。Function<Integer, Integer> 每次调用都要装箱入参、拆箱返回;IntUnaryOperator 全程使用 int,不产生 Integer 对象。在数值密集的管道里,这一差异会直接体现为分配速率与 GC 频率。
2.1.3 类型推断与目标类型
Lambda 没有独立类型,它的类型完全由上下文(目标类型)决定:
Function<String, Integer> f = s -> s.length(); // 赋值上下文
list.removeIf(s -> s.isEmpty()); // 方法参数上下文(Predicate<? super E>)
Object o = (Runnable) () -> System.out.println(); // 强转上下文
目标类型还决定了参数类型能否推断,因此同一段 Lambda 在不同上下文中可能编译失败:
// 编译失败:目标类型不明确
var f = s -> s.length();
// 编译通过:目标类型由变量声明给出
Function<String, Integer> f = s -> s.length();
方法重载是易错点:参数不带类型的隐式 Lambda 不参与重载决议的适用性判断,编译器无法据此区分两个同参数个数的重载,结果是编译错误或选中非预期的重载。
void submit(Supplier<String> s) { }
void submit(Callable<String> c) { }
submit(() -> "x"); // 编译错误:对 submit 的引用不明确
submit((Supplier<String>) () -> "x"); // 修复一:显式强转
Supplier<String> task = () -> "x";
submit(task); // 修复二:先赋值给有类型的变量
泛型本身的推断规则(通配符、目标类型推断、类型擦除的限制)见 Java 泛型。
2.1.4 Lambda 与匿名内部类的差别
| 维度 | Lambda | 匿名内部类 |
|---|---|---|
| 类文件 | 不生成独立的 .class(由运行期生成实现) | 每个匿名类生成 Outer$1.class |
| 绑定方式 | invokedynamic + LambdaMetafactory | new 指令直接实例化 |
this 语义 | 指外围实例 | 指匿名类实例自身 |
| 作用域 | 不引入新作用域,参数不能与外围局部变量同名 | 引入新作用域,可以遮蔽外围变量 |
| 实例创建 | 非捕获 Lambda 在同一调用点复用同一个实例 | 每次执行都新建实例 |
| 序列化 | 默认不可序列化 | 取决于实现的接口 |
| 调试显示 | lambda$method$0 | Outer$1 |
要点说明:
this的差异最容易引入 bug。在匿名内部类中调用this.field访问的是内部类字段,在 Lambda 中访问的是外围对象字段;从匿名内部类改写成 Lambda 时,原本需要Outer.this.field的地方直接变成field。- 实例复用是性能差异的主要来源。非捕获 Lambda(不引用任何外部变量)的实现在调用点被缓存,重复执行不会重复分配;匿名内部类每次执行都会分配对象。捕获了外部变量的 Lambda 仍需每次分配(用以存放捕获值),但在多数场景下可以被 JIT 的逃逸分析消除。
- 首次调用有链接开销。
invokedynamic的引导方法在第一次执行时完成绑定,之后才可被内联。这属于一次性的启动成本,不应据此判断长期性能。
结论:选择 Lambda 或匿名内部类的依据是语义(this、作用域、实例化次数),性能差异通常不是决定因素。
2.2 变量捕获与闭包
2.2.1 有效 final 的原因
Lambda 可以引用外围的局部变量与参数,但被引用的变量必须是有效 final(effectively final,即声明后未被重新赋值):
int base = 10;
Function<Integer, Integer> plus = x -> x + base; // 合法:base 此后不再修改
int offset = 0;
Runnable r = () -> System.out.println(offset);
offset = 1; // 编译错误:offset 不再是有效 final
根本原因是 Java 采取值捕获而不是引用捕获:Lambda 体在编译时把变量值复制到自身的合成字段中,Lambda 内部看到的是副本。若允许后续修改变量,副本与变量会不一致,语义无法定义;实现上也行不通——局部变量位于栈帧中,而 Lambda 可能在栈帧销毁之后、甚至在另一个线程上执行。
以下三种写法不受"有效 final"限制,因为它们捕获的不是局部变量的值:
class Demo {
private int counter; // 实例字段
private static int total; // 静态字段
void run(int[] buffer) { // 数组引用不变,元素可改
Runnable r1 = () -> counter++; // 隐式捕获 this
Runnable r2 = () -> total++; // 通过类引用访问静态字段
Runnable r3 = () -> buffer[0] = 1; // 捕获数组引用
}
}
r1 合法的原因是它捕获的是 this 引用(引用本身不变),修改的是对象字段。这一点在排查闭包相关问题时很关键:有效 final 只约束引用,不约束引用所指的对象。
2.2.2 捕获带来的生命周期延长与内存影响
被捕获对象的存活时间由 Lambda 决定,而不再由原来的作用域决定:
private static final List<Runnable> LISTENERS = new ArrayList<>();
void register(BigPayload payload) {
// payload 被长期持有:只要 LISTENERS 不清理,payload 就无法回收
LISTENERS.add(() -> handle(payload));
}
即使方法返回、原调用栈销毁,payload 仍被 Lambda 的合成字段引用。堆转储中表现为 Lambda 实例上形如 arg$1 的字段指向大对象。
常见的泄漏入口:
| 入口 | 表现 |
|---|---|
| 静态集合中的回调 | 注册后从不移除,收集到的对象随应用生命周期长存 |
| 单例中的监听器列表 | 每次请求追加一个 Lambda,列表持续增长 |
| 线程池任务队列 | 提交的任务尚未执行,任务中捕获的请求上下文无法释放 |
| 缓存 | 以 Lambda 作为缓存值,间接持有上下文对象 |
ThreadLocal 持有 Lambda | 线程池复用线程,值长期不清除 |
判断方式很直接:先看 Lambda 被谁持有,再看持有者活多久。凡是"注册/添加"而没有对应"注销/移除"路径的位置,都应检查捕获内容。
2.2.3 与线程安全的关系
闭包让共享可变状态变得隐蔽:从代码上看不出跨线程共享,因为不再需要显式传参。
List<String> buffer = new ArrayList<>(); // 引用不变,满足有效 final
Stream.of("a", "b", "c").parallel().forEach(buffer::add); // 对象被并发修改
上面这段代码是合法的(buffer 未被重新赋值),但它会丢数据、size 计数错误,甚至抛 IndexOutOfBoundsException。修复方式见 3.5.2。
三条结论:
- 有效 final 只保证引用的不变性,不保证线程安全;
- 捕获对象如果是可变容器,并发访问仍需同步或改用并发容器;
- Lambda 与并行流结合时,共享可变状态是最高频的错误形态(见 2.8.4、3.5.2)。
关于 volatile、happens-before 与锁的机制,见 Java 并发编程。
2.3 方法引用
2.3.1 四种形式
| 形式 | 语法 | 等价 Lambda | 说明 |
|---|---|---|---|
| 静态方法引用 | Integer::parseInt | s -> Integer.parseInt(s) | 参数按位置传入 |
| 绑定实例方法引用 | System.out::println | x -> System.out.println(x) | 接收者已确定 |
| 未绑定实例方法引用 | String::length | s -> s.length() | 接收者是第一个参数 |
| 未绑定实例方法引用(二元) | String::compareTo | (a, b) -> a.compareTo(b) | 第一个参数作接收者 |
| 构造器引用 | ArrayList::new | () -> new ArrayList<>() | 按目标签名选择构造方法 |
| 数组构造器引用 | int[]::new | n -> new int[n] | 接收长度参数 |
构造器引用会按目标函数接口的签名选择对应的构造方法:
Supplier<List<String>> newList = ArrayList::new; // () -> new ArrayList<>()
Function<Integer, List<String>> sizedList = ArrayList::new; // n -> new ArrayList<>(n)
IntFunction<int[]> newArray = int[]::new; // n -> new int[n]
2.3.2 使用时机
- 当 Lambda 体只是"调用一个已存在的方法并把参数原样传入"时,方法引用更短,且省去了无意义的参数名(
s -> System.out.println(s)中的s不携带任何信息)。 - 不要为了用方法引用而改造逻辑。需要常量、条件或额外参数时,显式 Lambda 更直白:
x -> foo(x, 1)优于为此新建一个包装方法。 - 方法名必须自带语义。
map(this::normalize)可读,map(Utils::t)不可读——方法引用丢掉了参数名,只剩方法名作为唯一的线索。 - 重载可能造成歧义。
Class::method若匹配多个重载签名会编译失败,此时改回带显式参数类型的 Lambda 解决:
// 只有单个重载可适配:正常编译
Function<String, Integer> f = Integer::parseInt;
// 同一方法名存在多个重载、且都能适配目标签名时,编译报"对方法的引用不明确"
// 解决方式:改回带显式参数类型的 Lambda,由参数类型参与重载决议
Function<Integer, String> g = (Integer i) -> String.valueOf(i);
2.4 函数组合
2.4.1 组合方法的方向与语义
| 方法 | 语义 | 求值顺序 |
|---|---|---|
Predicate.and(other) | 短路与 | 左侧为 false 时不再调用右侧 |
Predicate.or(other) | 短路或 | 左侧为 true 时不再调用右侧 |
Predicate.negate() | 取反 | — |
Function.andThen(after) | 先自身,再 after | f.andThen(g) 等价 x -> g(f(x)) |
Function.compose(before) | 先 before,再自身 | f.compose(g) 等价 x -> f(g(x)) |
Consumer.andThen(after) | 顺序执行两个消费者 | 先自身再 after |
Comparator.thenComparing(next) | 前比较相等时继续比较 | 链式多级排序 |
andThen 与 compose 的方向相反,是最容易记错的一对:
Function<Integer, Integer> plus1 = x -> x + 1;
Function<Integer, Integer> times2 = x -> x * 2;
plus1.andThen(times2).apply(3); // (3 + 1) * 2 = 8
plus1.compose(times2).apply(3); // (3 * 2) + 1 = 7
数据流方向记法:andThen 表示"然后"。
组合的边界:组合出来的函数在异常堆栈里看不到中间成员,出错时难以定位是哪一层出的问题;组合层次以两到三层为宜,更深的组合应拆成具名方法。
2.4.2 自定义函数式接口的取舍
优先使用 java.util.function 中的内置接口。自定义只在以下情况有价值:
| 场景 | 是否自定义 | 说明 |
|---|---|---|
| 需要表达职责的类型名 | 是 | OrderValidator 比 Function<Order, ValidationResult> 更能说明意图 |
| 需要抛出受检异常 | 是 | 内置接口不声明受检异常,IO 相关行为需自定义并在调用处包装 |
| 需要三个及以上参数 | 是 | 内置最多两个参数(BiXxx),多参数应改用记录类打包参数 |
| 只有一个使用点的简单转换 | 否 | 直接用 Function / Predicate |
| 仅为了让签名"看起来函数式" | 否 | 增加类型数量而没有信息增量 |
注意两点:自定义接口同样受 SAM 约束,声明两个抽象方法后就不能用 Lambda 实现;受检异常的包装会带来"在哪里处理异常"的新决策,包装点应尽量靠近调用边界。
2.4.3 柯里化与部分应用的适用边界
柯里化把 n 元函数转成 n 个一元函数的链;部分应用固定部分参数得到少参函数。Java 没有专门语法,只能手工返回函数:
// 部分应用:把租户信息固定进转换函数,供管道复用
static Function<Order, String> formatterFor(Tenant tenant) {
return order -> tenant.getPrefix() + order.getId();
}
Function<Order, String> formatter = formatterFor(currentTenant);
List<String> codes = orders.stream().map(formatter).toList();
适用边界:
- 适合:一组参数在多次调用中固定不变,固定后得到的函数能直接在管道中复用;
- 不适合:需要层层嵌套的柯里化(
f.apply(a).apply(b).apply(c)),其可读性远低于一个三参方法; - 代价:每次部分应用都创建一个新的闭包对象,并延长被固定参数的生命周期;在热点路径上应考虑一次性传入全部参数。
Java 中"部分应用"更常见的替代是显式传递配置对象或在调用点使用 Lambda,两者都比手工柯里化易读。只有在参数分组天然清晰、且复用确实存在时,手工部分应用才值得。
2.5 Optional 的设计意图
2.5.1 表达"可能没有值"的返回值
Optional 的原始动机是在类型层面标注"这个方法可能返回空",迫使调用方处理缺失分支,而不是依赖文档或经验。
Optional的定位是方法返回值的容器,不是通用的空值替代品。
它不能替代 null,原因有三:
Optional自身是引用,仍可能为null;返回null的Optional比返回null更危险,因为调用方已经假设容器非空;- 它增加一个包装对象与一次间接取值,出现在字段、参数、集合元素时会放大分配与调用成本;
- 它未实现
Serializable,不能作为 DTO、会话状态、缓存值的存储形态。
2.5.2 与 null 的边界
| 位置 | 是否使用 Optional | 替代做法 |
|---|---|---|
| 方法返回值(可能无值) | 可以 | — |
| 单值查询且"无值"属异常 | 不建议 | 抛业务异常 |
| 集合返回值 | 不可以 | 返回空集合(List.of()、Collections.emptyList()) |
| 数组返回值 | 不可以 | 返回长度 0 的数组 |
| 方法参数 | 不可以 | 重载、默认值、配置对象 |
| 字段(实体、DTO、record 组件) | 不可以 | 可空引用配合显式约定,或空对象与默认值 |
| 集合元素 | 不可以 | 集合本身约定不允许 null,或改用 Map 表达 |
| 局部变量 | 一般不建议 | 直接使用值并做条件判断 |
2.5.3 常用链式方法的语义差异
| 方法 | 语义 | 易错点 |
|---|---|---|
map(f) | 有值时转换 | f 返回 null 时结果为 Optional.empty(),而不是抛异常 |
flatMap(f) | f 返回 Optional,避免嵌套 | 返回类型写错会得到 Optional<Optional<T>> |
filter(p) | 不满足条件则变空 | 与 map 的顺序会影响判断对象 |
or(Supplier)(Java 9+) | 空时换用另一个 Optional | 参数是 Supplier,不会无条件求值 |
orElse(v) | 空时返回 v | v 无论是否有值都会先求值 |
orElseGet(Supplier) | 空时调用 supplier | 需要惰性求值或存在开销时应使用它 |
orElseThrow(...) | 空时抛异常 | Java 10+ 提供无参版本 |
ifPresent(Consumer) | 有值时执行 | 用于副作用,注意不要在其中做复杂逻辑 |
ifPresentOrElse(c, r)(Java 9+) | 有值与空分别处理 | — |
get() | 取值 | 空时抛 NoSuchElementException,应视为最后手段 |
isEmpty()(Java 11+) | 判空 | 与 isPresent() 相对 |
stream()(Java 9+) | 转成 0 或 1 个元素的流 | 便于与 Stream 管道衔接 |
orElse 与 orElseGet 的差别是高频错误来源:
// loadDefault() 总会被执行,即使 opt 有值
String a = opt.orElse(loadDefault());
// 仅当 opt 为空时才执行
String b = opt.orElseGet(this::loadDefault);
2.5.4 常见误用
| 误用 | 问题 |
|---|---|
private Optional<String> name; 作为字段 | 增加内存与序列化问题,访问时需要处理两层"可能没有" |
Optional 作为方法参数 | 调用方被迫构造容器,且仍需处理 null 与空两种缺失 |
Optional 作为集合元素 | 集合本身已能表达"没有元素",再包一层语义混乱 |
用 isPresent() + get() 写回命令式判断 | 退化成一串 if,不如直接返回可空值或使用 orElse |
长链 map/filter/map/filter/orElseGet | 超过三四个环节后难以阅读,应拆成具名方法 |
Optional.of(maybeNull) | 传入 null 时立即抛 NullPointerException,应使用 ofNullable |
集合返回 Optional<List<T>> | 空集合已能表达"没有",包装属多余 |
直接调用 get() 而不判断 | 把一种运行时异常换成了另一种 |
返回 null 的 Optional | 破坏了类型承载的承诺,调用方无从判断 |
空值语义在团队规范中的位置见 3.3 与 3.6,静态检查与门禁的机制见 代码质量与静态分析。
2.6 Stream 管道模型
2.6.1 三部分构成
Stream 的操作分为三类:
| 分类 | 返回值 | 是否触发执行 | 典型方法 |
|---|---|---|---|
| 源(Source) | Stream | 否 | list.stream()、Arrays.stream()、Stream.of()、IntStream.range() |
| 中间操作(Intermediate) | Stream | 否 | filter、map、flatMap、distinct、sorted、limit、peek |
| 终止操作(Terminal) | 非 Stream | 是 | collect、toList、forEach、count、reduce、findFirst、anyMatch |
源的常见来源:
list.stream(); // 集合
Arrays.stream(array); // 数组
Stream.of("a", "b"); // 显式元素
IntStream.range(0, 100); // 数值范围(无装箱)
Files.lines(path); // 文件行
BufferedReader.lines(); // 字符流
pattern.splitAsStream(text); // 正则拆分
new Random().ints(10); // 随机数
Stream.iterate(0, n -> n + 2); // 无限流
Stream.generate(Math::random); // 无限流
Optional.of(x).stream(); // Java 9+,0 或 1 个元素
数值流(IntStream、LongStream、DoubleStream)提供 sum()、average()、summaryStatistics() 与 boxed(),是避免装箱的主要手段;summaryStatistics() 一次遍历即可得到计数、求和、最小值、最大值与平均值。
2.6.2 惰性求值与执行时机
中间操作不执行任何计算,它们只是把阶段串成一条管道(内部由 AbstractPipeline 的 sourceStage/previousStage/nextStage 与各类 Sink 组成)。只有终止操作才会从源拉取元素并穿过整条管道。
stream.filter(x -> x > 0).map(this::expensive); // 没有任何执行发生
执行模型是垂直执行:每个元素依次走完全部阶段,再处理下一个元素。
元素 e1 → filter → map → collect
元素 e2 → filter → map → collect
元素 e3 → filter → map → collect
而不是水平执行(每个操作遍历一遍全部元素)。这一模型是短路与无限流得以成立的前提:只要下游不再索要元素,上游就不会继续生产。
由此产生两个推论:
peek观察到的内容取决于它在管道中的位置(放在filter之前看到的是全部元素,放在之后只看到通过过滤的元素);- 若中间某阶段把元素"吃掉"(过滤掉)或只取一部分,后面阶段的副作用执行次数也会相应减少。
2.6.3 有状态操作
有状态操作必须保存已见元素或依赖整体顺序,无法逐元素独立完成:
| 操作 | 状态 | 代价 |
|---|---|---|
filter、map、flatMap、peek、mapToXxx、boxed | 无状态 | 逐元素处理,可并行 |
distinct | 有状态 | 维护已见集合,内存为 O(不重复元素数) |
sorted | 有状态且是屏障 | 缓冲全部元素,内存 O(n),必须等源全部就绪 |
limit、skip | 有状态 | 顺序流中可短路;并行流中需按遭遇顺序协调 |
takeWhile、dropWhile(Java 9+) | 有状态 | 依赖顺序判断,并行下几乎没有收益 |
要点:
sorted()使无限流永不返回,sorted().findFirst()同样要先完成全量排序;- 有状态操作在并行流中需要缓冲与合并,往往比顺序流更慢,并破坏内存局部性;
limit在顺序流中是短路的(达到数量后不再向上游索要),因此Stream.iterate(...).limit(n)可以终止;并行流中limit需要按遭遇顺序协调,代价明显更高。
2.6.4 短路操作与无限流
短路(short-circuiting)指不必处理全部元素即可得出结果:
- 短路的中间操作:
limit(顺序流)、takeWhile(Java 9+); - 短路的终止操作:
findFirst、findAny、anyMatch、allMatch、noneMatch。
// 无限流 + 短路终止操作:可以正常结束
Optional<Integer> firstOver100 = Stream.iterate(1, n -> n + 1)
.filter(n -> n > 100)
.findFirst();
无限流上缺少短路操作时永不返回,count()、forEach()、sorted()、reduce() 都属于这类情况。
2.6.5 一次消费
Stream 是一次性的:终止操作之后管道已关闭,再次使用会抛 IllegalStateException: stream has already been operated upon or closed。
Stream<String> s = list.stream().map(String::trim);
s.count();
s.findFirst(); // IllegalStateException
需要重复使用同一个"操作序列"时,应把它封装成返回新 Stream 的方法,而不是缓存 Stream 对象(见 3.5.4)。
2.6.6 遭遇顺序
源是否定义"遭遇顺序"(encounter order)会影响并行行为与结果可预期性:
| 源 | 遭遇顺序 | 说明 |
|---|---|---|
List、数组、IntStream.range | 有 | 顺序确定,可预期 |
HashSet、HashMap 的键集 | 无 | 迭代顺序不稳定 |
LinkedHashSet、LinkedHashMap 的键集 | 有 | 插入顺序 |
TreeSet、TreeMap 的键集 | 有 | 排序顺序 |
sorted() 之后的流 | 有 | 排序确定了顺序 |
声明 unordered() 之后的流 | 无 | 放弃顺序,部分操作在并行下更高效 |
unordered() 的收益是让 distinct、limit、skip 在并行下无需维护顺序协调;代价是结果顺序不可预期。只有在顺序确实无关时才使用它。
2.7 归约与收集器
2.7.1 reduce 的三种形态
// 一:无初始值,空流返回 Optional.empty()
Optional<T> reduce(BinaryOperator<T> accumulator);
// 二:有初始值
T reduce(T identity, BinaryOperator<T> accumulator);
// 三:带合并函数,combiner 只在并行时用于合并分片结果
<U> U reduce(U identity, BiFunction<U, T, U> accumulator, BinaryOperator<U> combiner);
形态二在并行下会把 identity 用作每个分片的初始值,因此存在两条硬性要求:identity 必须是该运算的单位元,且必须是不可变对象。
经典错误:用可变容器作为 identity。
// 错误:identity 被多个分片共享,结果出现重复元素或元素丢失
List<String> all = stream.parallel()
.reduce(new ArrayList<>(), // 共享的可变容器
(acc, e) -> { acc.add(e); return acc; },
(a, b) -> { a.addAll(b); return a; });
修复:集合类结果一律改用 collect(每个分片有独立的容器,见 2.7.5)。
2.7.2 结合律要求
并行归约要求累加函数满足结合律,identity 是单位元;否则结果取决于分片方式,不可预期。
| 运算 | 满足结合律 | 顺序流 | 并行流 |
|---|---|---|---|
| 整数加、乘、取最大、取最小 | 是 | 确定 | 确定 |
| 整数减 | 否 | 按从左到右确定 | 依赖分片,不可预期 |
字符串拼接(+、concat) | 是(不满足交换律) | 确定 | 元素顺序取决于分片与合并顺序,可能乱序 |
| 浮点加法 | 不严格满足 | 确定 | 累加顺序不同可能产生微小差异 |
结论:并行归约只应使用真正满足结合律的运算;顺序敏感的拼接应使用顺序流,或改用 Collectors.joining 配合有序源。
2.7.3 Collectors 常用收集器
| 分类 | 收集器 | 说明 |
|---|---|---|
| 转集合 | toList()、toSet()、toCollection(Supplier) | 类型与可变性由具体收集器决定 |
| 不可变集合 | toUnmodifiableList()、toUnmodifiableSet()、toUnmodifiableMap()(Java 10+) | 结果只读 |
| 转 Map | toMap(k, v)、toMap(k, v, merge)、toMap(k, v, merge, mapFactory) | 键冲突与空值需显式处理 |
| 并发 Map | toConcurrentMap(...) | 并行收集时使用 |
| 分组 | groupingBy(classifier)、groupingBy(classifier, downstream)、groupingBy(classifier, mapFactory, downstream) | 默认返回 HashMap |
| 并发分组 | groupingByConcurrent(...) | 并行下避免逐组合并 |
| 分区 | partitioningBy(predicate)、partitioningBy(predicate, downstream) | 结果必然是二分 |
| 聚合 | counting()、summingInt/Long/Double()、averagingXxx()、reducing()、maxBy()、minBy() | 数值聚合 |
| 字符串 | joining()、joining(delim)、joining(delim, prefix, suffix) | 拼接 |
| 映射与扁平 | mapping(f, downstream)、flatMapping(f, downstream)(Java 9+) | 分组后的二次变换 |
| 后处理与并行二分 | collectingAndThen(downstream, finisher)、teeing(d1, d2, merger)(Java 12+) | 结果加工与双路归并 |
必须记住的语义点:
groupingBy的返回类型默认是HashMap,顺序不确定;需要稳定顺序时使用三参版本传入LinkedHashMap::new,需要按键排序传入TreeMap::new。groupingBy的分类函数不允许返回null,否则抛NullPointerException;需要保留未知分组时应先把键映射成占位值(如"UNKNOWN")。partitioningBy与groupingBy的差别在空分组:前者结果中必然同时包含true与false两个键(即使某一侧为空容器),后者不产生空分组。toMap遇到重复键默认抛IllegalStateException: Duplicate key,必须显式提供合并函数;合并函数的两个参数是(已存在的值, 新值),顺序容易记错。toMap的值不允许为null:内部使用Map.merge,而merge拒绝null值,会抛NullPointerException。- 下游收集器是分组的核心用法:
groupingBy(k, counting())、groupingBy(k, summingInt(..))、groupingBy(k, mapping(v, toList()))、多级groupingBy嵌套。
2.7.4 自定义收集器与 Collector 的四个方法
Collector<T, A, R> 由四个方法与一组特征标志构成:
| 成员 | 签名 | 职责 |
|---|---|---|
supplier() | Supplier<A> | 创建可变结果容器(每个分片各调用一次) |
accumulator() | BiConsumer<A, T> | 把一个元素归入容器 |
combiner() | BinaryOperator<A> | 合并两个分片容器(仅并行) |
finisher() | Function<A, R> | 容器到最终结果的转换 |
characteristics() | Set<Characteristics> | CONCURRENT、UNORDERED、IDENTITY_FINISH |
// 收集订单号为逗号分隔的字符串,展示四个方法的对应关系
Collector<Order, StringBuilder, String> ids =
Collector.of(
StringBuilder::new, // supplier
(sb, o) -> sb.append(o.getId()).append(','), // accumulator
(left, right) -> left.append(right), // combiner
sb -> sb.length() == 0 ? "" : sb.substring(0, sb.length() - 1) // finisher
);
特征标志的含义与约束:
IDENTITY_FINISH:finisher是恒等函数(A与R同类型),声明后可跳过最后一步转换;UNORDERED:收集结果与遭遇顺序无关;CONCURRENT:accumulator可以多线程同时作用于同一个容器。当收集器声明了CONCURRENT但未声明UNORDERED时,只有在数据源本身无序的情况下才会真正共用同一个容器,否则仍退化为"每个分片一个容器"。声明CONCURRENT的前提是容器本身线程安全,这是最容易写错的一处。
选择依据:能用标准收集器组合出来的不要手写 Collector;手写只适用于需要复用、且标准组合确实表达不了(例如需要专用的可变累加器结构)的场景。
2.7.5 collect 与 reduce 的分工
| 维度 | reduce | collect |
|---|---|---|
| 容器 | 每次合并产生新对象 | 复用可变容器 |
| 适用 | 数值、不可变值的标量聚合 | 收集到集合、字符串、统计对象 |
| 并行代价 | 中间对象多 | 分片容器 + 合并 |
| 约束 | 满足结合律与单位元 | accumulator 与 combiner 实现正确 |
集合类结果一律用 collect;reduce 用于标量聚合。这条分工同时解决了"用可变 identity 做集合归约"的错误。
2.8 并行流
2.8.1 背后的 ForkJoinPool 与公共池
并行流默认在 ForkJoinPool.commonPool() 上执行,它是 JVM 全局共享的池:
- 并行度默认为"可用处理器数 − 1"(可用处理器为 1 时并行度为 1);
- 使用公共池的不止并行流:
Arrays.parallelSort、Arrays.parallelSetAll、未指定执行器的CompletableFuture异步任务都共享它; - 若并行流是在某个
ForkJoinPool的工作线程内被调用,任务会提交到当前线程所属的池,而不是公共池。
高危:通过系统属性 java.util.concurrent.ForkJoinPool.common.parallelism 调整公共池并行度,是 JVM 级全局变更。
影响范围:所有依赖公共池的代码(并行流、Arrays.parallelSort、未指定执行器的 CompletableFuture)的并发度同时改变。调大可能引起 CPU 争用与其他组件的延迟上升;调小会让并行流的收益消失甚至变慢。该属性只在启动时读取,运行期无效。
回滚方式:删除或还原该 JVM 启动参数并重启实例,无法运行期热改;若使用容器编排平台,需同步回退部署配置与镜像的环境变量定义,并在回退前后对比线程数与基线指标(方法见 3.4.3)。
线程池本身的机制(核心线程、工作队列、拒绝策略)见 Java 并发编程 第九节。
2.8.2 拆分与合并策略
并行流的拆分能力由源的 Spliterator 决定:trySplit() 把源切成两半,递归提交任务,各分片的结果再由收集器或归约的 combiner 合并。
| 源 | 拆分能力 | 说明 |
|---|---|---|
数组、ArrayList、IntStream.range | 好 | 可按索引区间平分 |
HashMap 的键集/条目集 | 较好 | 按桶分片,各片大小不均衡 |
LinkedList、TreeMap | 差 | 只能顺序切分,成本高且不均衡 |
Iterator 转换的源 | 差 | 无法估算规模 |
Stream.iterate、Stream.generate | 很差 | estimateSize 为 Long.MAX_VALUE,无法有效拆分 |
| 有状态中间操作之后 | 变差 | sorted、distinct 之前是屏障,输入必须先全量缓冲 |
estimateSize 与实际规模不符时任务划分会失衡:一部分线程提前空闲,另一部分仍在处理大分片,实际并行度低于预期。
2.8.3 适用条件
四条同时成立时才考虑并行:
- 数据量足够大:元素数与单元素工作量的乘积要能覆盖任务拆分、提交与合并的开销。数千到数万元素以下通常没有收益;只做一次简单比较的场景,百万级也可能不如顺序流。
- 元素处理相互独立:没有共享可变状态,处理顺序不影响结果。
- 源可高效拆分:参照 2.8.2 的表格。
- 不在意顺序:需要顺序时使用
forEachOrdered或顺序流;顺序要求在并行下会引入协调成本。
任一条不满足时,并行不是优化而是风险。
2.8.4 常见陷阱
| 陷阱 | 表现 | 后果 |
|---|---|---|
| 共享可变状态 | forEach 中向普通集合累加 | 数据静默丢失、结构破坏、抛越界异常 |
| 有状态操作拖累并行 | 管道中存在 sorted、distinct、limit、skip | 需缓冲与顺序协调,可能比顺序流更慢 |
| 阻塞调用污染公共池 | 管道中做 IO、远程调用、加锁 | 公共池工作线程被占用,拖慢全局所有使用者 |
| 与自定义线程池混用 | 在自建 ForkJoinPool 中执行并行流 | 引入线程管理、嵌套并行、关闭语义等新问题(见 3.4.2) |
| 异常传播 | 某分片抛异常 | 传播到终止操作,其余分片不保证被取消 |
| 性能负向 | 小数据、装箱、缓存局部性下降 | 并行版本更慢,且难以察觉 |
关于"公共池饥饿"的完整成因与排查见 3.5.3。
2.9 工程边界
2.9.1 适合与不适合的场景
| 场景 | 建议 |
|---|---|
| 集合的过滤、映射、分组、聚合 | 用 Stream |
| 每元素独立、无共享状态的数据变换 | 用 Stream |
需要早退、多层嵌套循环、带标签的 break/continue | 用循环 |
| 需要读写外部可变状态(累加、写入集合、发消息) | 用循环,或先用 Stream 收集再统一处理 |
| 需要元素下标参与逻辑 | 循环更自然(IntStream.range 可行但可读性下降) |
| 需要抛出受检异常的 IO 逻辑 | 循环,或在边界处显式包装受检异常 |
| 元素极少(一到三个)的简单处理 | 循环,避免管道开销与阅读成本 |
| 性能敏感的热点路径 | 先测量;通常保留循环(见 3.4.3) |
| 数据库能完成的聚合 | 下推到数据库(见 3.2.4) |
2.9.2 可读性判断
判断标准是"读者能否在不模拟执行的情况下理解意图",而不是操作数量的多少:
- 管道每行一个阶段、阶段名称表达业务含义时,可读性优于循环;
- 一条链超过五到七个阶段,或出现多层嵌套的
flatMap、多级groupingBy时,应拆成具名方法; peek用于临时调试可以接受,进入生产代码会引入副作用并让读者误判执行时机;- 同一代码库内保持一致:简单聚合用 Stream,复杂控制流用循环,不做一刀切。
2.9.3 调试与堆栈可读性
| 现象 | 原因 | 应对 |
|---|---|---|
堆栈中出现 lambda$method$0 | Lambda 无独立类名 | 结合外围方法名定位,必要时提取为具名方法 |
堆栈中出现 ClassName$$Lambda$N/0x... | 方法引用的运行期实现 | 同上 |
堆栈多出若干 java.util.stream 帧 | 管道的内部阶段 | 关注最上层的业务帧 |
| 异常行号指向整条链的起始行 | 多行链的字节码行号归属 | 把可疑阶段拆成独立方法 |
| 并行流异常堆栈跨线程 | 异常在某个分片线程抛出 | 在异常消息中带上元素标识,便于定位输入 |
peek 是观察元素流向的手段,但它可能因为短路而不被调用,也可能因为优化而不执行,不能作为可靠的生产埋点。
2.9.4 性能敏感路径的取舍
- 决策顺序是先测量、再修改、后回归,方法见 3.4.3 与 性能测试与基线;
- 简单循环在热点路径上仍有优势:无管道对象、无 Lambda 调用点、无装箱、可被 JIT 直接优化;
- 若必须使用 Stream,优先用数值流消除装箱,并把过滤阶段尽量前置以减少下游元素数;
- 冷路径(单次请求执行一次、数据量小)优先可读性,不必为微秒级差异牺牲表达力。
三、实现
3.1 集合处理实践
3.1.1 过滤与映射的改写对照
// 改写前
List<String> result = new ArrayList<>();
for (Order order : orders) {
if (order.getStatus() == Status.PAID) {
result.add(order.getId());
}
}
// 改写后
List<String> result = orders.stream()
.filter(o -> o.getStatus() == Status.PAID)
.map(Order::getId)
.toList();
结果集合的类型由终止操作决定,需要按用途显式选择:
List<String> a = orders.stream().map(Order::getId).toList(); // Java 16+,不可修改
List<String> b = orders.stream().map(Order::getId).collect(Collectors.toList()); // 通用写法
List<String> c = orders.stream().map(Order::getId)
.collect(Collectors.toCollection(ArrayList::new)); // 明确可变与类型
注意 toList() 允许 null 元素;toUnmodifiableList()(Java 10+)同样只读,但不接受 null。
3.1.2 分组与统计的改写对照
// 改写前:按状态分组计数
Map<Status, Long> countByStatus = new HashMap<>();
for (Order order : orders) {
countByStatus.merge(order.getStatus(), 1L, Long::sum);
}
// 改写后
Map<Status, Long> countByStatus = orders.stream()
.collect(Collectors.groupingBy(Order::getStatus, Collectors.counting()));
// 数值统计:一次遍历得到计数、求和、最小、最大、平均
DoubleSummaryStatistics stats = orders.stream()
.mapToDouble(Order::getAmount)
.summaryStatistics();
改写时不要顺手改变结果类型:groupingBy 默认返回 HashMap,若下游依赖顺序,需要显式指定 LinkedHashMap::new 或 TreeMap::new。
3.1.3 改写后的核对方式
两个方向都要核对,缺一不可:
- 可读性核对:把管道逐行读成业务句子("取已支付订单的 id")。若需要反复跳行、回头才能读懂,说明阶段划分不合理或职责混合过多。
- 性能核对:对同一输入分别测量循环版与 Stream 版,注意预热、避免死代码消除,并核对元素数量级与数据类型。不能用"Stream 更慢"或"Stream 更快"这类笼统判断替代实测。
改写的目的首先是把意图与流程分离,其次才是性能。若改写后意图没有更清晰,保留原写法是正确决定。
3.2 数据聚合实践
3.2.1 分组统计与多级分组
// 按城市分组统计订单数与金额
Map<String, Long> countByCity = orders.stream()
.collect(Collectors.groupingBy(
o -> o.getCustomer().getCity(),
Collectors.counting()));
Map<String, Double> amountByCity = orders.stream()
.collect(Collectors.groupingBy(
o -> o.getCustomer().getCity(),
Collectors.summingDouble(Order::getAmount)));
// 多级分组:城市 → 状态 → 订单号列表
Map<String, Map<Status, List<String>>> idsByCityAndStatus = orders.stream()
.collect(Collectors.groupingBy(
o -> o.getCustomer().getCity(),
Collectors.groupingBy(
Order::getStatus,
Collectors.mapping(Order::getId, Collectors.toList()))));
注意点:
- 分类函数返回
null会抛NullPointerException,需要保留未知分组时应先映射成占位值; - 多级分组会产生大量小集合,分组键基数很高时(如按订单号分组)内存膨胀明显,这类需求通常应在数据库侧完成;
- 需要保留城市出现顺序时使用
groupingBy(classifier, LinkedHashMap::new, downstream);需要按键排序使用TreeMap::new。
3.2.2 Top N 与排序
// 全量排序后取前 10
List<Order> top10 = orders.stream()
.sorted(Comparator.comparingDouble(Order::getAmount).reversed())
.limit(10)
.toList();
高危:在应用侧对大集合做全量物化与全量排序。
// 危险:把大结果集全部读入内存后再排序
List<Order> all = orderMapper.selectAll(); // 全量加载
List<Order> top10 = all.stream()
.sorted(Comparator.comparingDouble(Order::getAmount).reversed())
.limit(10)
.toList();
影响:selectAll 把全部行加载为对象,堆内存占用与 GC 压力随行数线性上升;sorted 会再复制一份元素数组作为缓冲,瞬时内存约为原集合的 1 倍以上。在容器内存限制下,直接后果是 Full GC 频繁甚至 OOM 被杀,表现为"没有业务异常日志的进程消失"。
回滚方式:该操作无运行期回滚手段,只能通过代码回退(还原为 SQL 侧 ORDER BY ... LIMIT)并重启发布;因此变更前必须在与生产同量级的数据上验证内存峰值,或改用分批读取。
同时,即便保留应用侧求 Top N,也应避免先整体 sorted 再 limit:固定大小的 Top N 用优先队列是 O(n log k),而全量排序是 O(n log n) 并且必须缓冲全部元素。
// 优先队列求 Top N:不需要全量缓冲
PriorityQueue<Order> heap = new PriorityQueue<>(
Comparator.comparingDouble(Order::getAmount)); // 小顶堆
for (Order o : orders) {
heap.offer(o);
if (heap.size() > 10) {
heap.poll();
}
}
List<Order> top10 = new ArrayList<>(heap);
top10.sort(Comparator.comparingDouble(Order::getAmount).reversed());
3.2.3 去重与自定义相等性
distinct() 依据元素的 equals 与 hashCode,无法按"某个字段相同即视为重复"去重。
// 无效:Order 未重写 equals,distinct 按身份判重,结果条数不变
long n = orders.stream().distinct().count();
// 按订单号去重并保留先出现的记录
Collection<Order> deduped = orders.stream()
.collect(Collectors.toMap(
Order::getId,
o -> o,
(first, second) -> first))
.values();
其他做法及适用条件:
| 做法 | 适用条件 |
|---|---|
先 map 出业务键再 distinct | 只需要去重后的键 |
TreeSet + 自定义 Comparator | 可比较且接受"比较结果为 0 即同一元素"的语义 |
Collectors.toMap + 合并函数 | 需要保留记录本身,并明确冲突取舍 |
数据库侧 DISTINCT / GROUP BY | 数据来自数据库且量级较大 |
equals/hashCode 契约与比较器语义的细节见 Java 集合框架实现原理 第八节。
3.2.4 与数据库聚合的分工
原则:能在数据库完成的聚合下推到数据库,应用侧只做数据库不便表达的部分。
| 需求 | 数据库侧 | 应用侧 |
|---|---|---|
| 计数、求和、平均 | GROUP BY + 聚合函数,配合索引 | 直接取结果 |
| 分组后每组若干条 | GROUP BY 或窗口函数 | 仅做展示层组装 |
| Top N | ORDER BY ... LIMIT | 仅做格式化 |
| 去重 | DISTINCT / GROUP BY | 补充业务级判重 |
| 跨数据源合并 | 无法表达 | 在小结果集上做二次加工 |
把全量数据拉到应用内存再聚合,会同时付出网络传输、对象创建、GC 与内存峰值的代价。把整张表查出来再用 Stream 求 sum,在百万行规模下既慢又危险。
只有在数据源不是数据库(内存中的配置、外部接口的一次性返回),或聚合口径需要跨数据源合并时,应用侧聚合才是合理选择。
数据库侧聚合的执行方式、索引与下推条件、EXPLAIN 的判读方法见 索引与执行计划 的计数与聚合一节;数据访问层的事务边界、分页与批量、SQL 治理见 持久层。
3.3 Optional 实践
3.3.1 返回值边界约定
约定应显式写进团队规范,而不是依赖个人习惯:
| 返回值类型 | 约定 |
|---|---|
| 可能无值的单值查询 | 返回 Optional<T>,不返回 null |
| 单值查询且"无值"属于异常 | 抛业务异常,不用 Optional |
| 集合 / 数组 | 返回空集合 / 空数组,不返回 null,也不用 Optional 包装 |
Map 查询结果 | 用 containsKey + get 或 getOrDefault |
| 基本类型 | 避免 OptionalInt 与包装类型混用造成语义不一致 |
// 返回 Optional:调用方必须处理缺失分支
public Optional<User> findById(long id) {
User user = repository.selectById(id); // 仓储可能返回 null
return Optional.ofNullable(user); // 在边界处立刻转为空容器
}
3.3.2 与外部接口的兼容处理
- 老接口或第三方 SDK 返回
null:在边界处立即用Optional.ofNullable包装,不让null向内继续传播; - 需要与只接受
null的框架(部分序列化框架、反射注入、老版本 ORM)交互时,在边界处用orElse(null)转换回来,Optional只停留在内部逻辑中; - 不要把
Optional放进 DTO、会话状态、缓存值或消息体:它未实现Serializable,且会改变对外契约。
3.3.3 领域模型中的替代写法
| 需求 | 替代写法 |
|---|---|
| "没有值"但有自然默认 | 空对象模式(NoDiscount、EmptyAddress)或默认值 |
| 缺失属于非法状态 | 在构造或解析处即校验并抛异常,让类型始终持有有效值 |
| 多个可选字段构成的状态 | 用密封接口与记录类表达有限状态("未绑定/已绑定"),而非若干 Optional 字段 |
| 可选配置项 | 配置类中给出默认值,读取时统一收敛 |
判断依据:如果"缺失"在领域语义上有明确含义,就应把它建成类型,而不是用 Optional 临时承载。
3.4 并行流实践
3.4.1 判断是否可以并行
按顺序逐条核对,任一条不满足就不并行:
1. 数据量是否足够大(元素数 × 单元素工作量)?
2. 每个元素的处理是否完全独立(无共享可变状态)?
3. 源是否可以高效拆分(数组 / ArrayList / 数值范围,而非 LinkedList 或迭代器)?
4. 结果是否与处理顺序无关?
5. 管道中是否包含有状态的中间操作(sorted / distinct / limit / skip)?
6. 是否存在阻塞调用(IO、远程调用、加锁)?
第 5、6 条为"是"时,通常不应并行。
高危:把已在生产运行的顺序流改为并行流(parallelStream() 或 stream().parallel())。
影响:处理线程从调用线程变为公共池工作线程,可能同时改变三件事——共享可变状态从"单线程安全"变成"并发不安全"(静默丢数据)、阻塞调用从"占用业务线程"变成"占用全局公共池"(拖慢其他功能)、有状态操作的缓冲与合并带来额外的内存与延迟峰值。由于公共池是全局资源,影响面不限于本次改动的功能。
回滚方式:删除 .parallel() / 改回 stream() 即可恢复原语义,代码回退后重新发布即可生效,无需调整 JVM 参数;若同时改过 java.util.concurrent.ForkJoinPool.common.parallelism,需一并回退启动参数并重启(见 2.8.1)。变更前必须完成 3.4.3 的测量与共享状态检查。
3.4.2 线程池隔离与自定义 ForkJoinPool
高危:把并行流的执行从公共池迁移到自定义 ForkJoinPool,属于运行期调度行为的变更。
ForkJoinPool pool = new ForkJoinPool(4);
try {
List<Result> results = pool.submit(() ->
data.parallelStream()
.map(this::computePureCpu)
.toList()
).join();
// 使用 results
} finally {
pool.shutdown();
}
(ForkJoinPool 实现了 ExecutorService,submit 返回 ForkJoinTask。)
影响:
- 自建池的线程数、队列与生命周期需要自行管理;线程数设置不当会导致 CPU 争用或并行度不足;
- 池内任务若再次触发并行流,会复用同一个池,可能出现嵌套并行导致线程占满;
- 池被关闭或未正确关闭时,任务会抛
RejectedExecutionException或导致线程泄漏; ForkJoinPool不提供"有界队列 + 拒绝策略"式的背压,任务提交过多只会转化为池内排队与内存增长。
回滚方式:
- 恢复为默认的公共池执行,即删除自定义池的包装层,回到
stream().parallel(),代码回退后重新发布即可; - 若自定义池被注册为全局执行器(例如传给
CompletableFuture的默认执行器设置),需一并回退该处引用; - 变更前后对比线程数与基线指标(见 3.4.3),确认公共池工作线程数是否回落。
更稳妥的替代:需要隔离的 IO 密集任务改用独立的 ThreadPoolExecutor 配合 CompletableFuture(见 3.4.4),把并行流留给纯 CPU 的批量数据变换。
3.4.3 并行下的度量方法
并行收益必须实测,步骤与要点:
- 建立基线:记录顺序流版本的吞吐、延迟分布、CPU 使用与 GC 分配速率,采集与对比流程参照 性能测试与基线 的基线采集与回归对比方法。
- 一次只改一个变量:仅改变"顺序/并行",使用相同的预热轮次与测量轮次,取中位数作为结论。
- 确认线程归属:线程列表中出现
ForkJoinPool.commonPool-worker-N说明正在使用公共池;若自定义池生效,应出现对应的池线程名。工作线程长期处于阻塞状态,说明管道中存在阻塞调用(对应 3.5.3)。 - 观察 CPU:并行有效的标志是多核同时繁忙且总耗时下降;若 CPU 未上升而耗时不变,说明拆分失败(源不可拆分或任务量太小)。
- 观察内存与 GC:分片、缓冲(有状态操作)与合并阶段会引入额外分配;若 GC 时间上升抵消了收益,应放弃并行。
- 避免误测:测量包含预热过程时结果不可比;未消费的中间结果可能被优化掉,需确保最终结果被真正使用。
3.4.4 与 CompletableFuture 的分工
| 维度 | 并行流 | CompletableFuture |
|---|---|---|
| 模型 | 数据并行(同一操作作用于大量元素) | 任务编排(多个异步任务及依赖关系) |
| 适用 | 纯 CPU 的批量数据变换 | IO 密集、需要超时/降级/组合/异常处理的调用 |
| 线程来源 | 公共池(全局共享) | 可指定专用执行器 |
| 顺序 | 可选择保留遭遇顺序 | 无顺序概念 |
| 阻塞容忍 | 差(阻塞会占用公共池线程) | 可隔离到独立池 |
| 组合能力 | 弱(只有管道) | 强(thenCombine、allOf、orTimeout、exceptionally) |
判断规则:对一批同构数据做相同计算用并行流;对多个不同的远程或 IO 操作做并行与组合用 CompletableFuture。 在并行流中做远程调用是两类需求的混淆,也是公共池饥饿的常见成因。
并发原语、线程池参数与线程安全策略见 Java 并发编程。
3.5 常见问题与排查
3.5.1 toMap 键冲突
现象:IllegalStateException: Duplicate key ...,堆栈指向终止操作所在的行。
// 错误:键重复直接抛异常
Map<Long, Order> byId = orders.stream()
.collect(Collectors.toMap(Order::getId, o -> o));
修复:提供合并函数,明确冲突时的取舍。
// 保留先出现的
Map<Long, Order> byId = orders.stream()
.collect(Collectors.toMap(Order::getId, o -> o, (first, second) -> first));
// 保留后出现的
Map<Long, Order> byId2 = orders.stream()
.collect(Collectors.toMap(Order::getId, o -> o, (first, second) -> second));
// 冲突项不丢弃,收集为列表
Map<Long, List<Order>> grouped = orders.stream()
.collect(Collectors.groupingBy(Order::getId));
合并函数的参数顺序是(已存在的值, 新值)。另一个相关陷阱是值映射返回 null 时的 NullPointerException(toMap 内部使用 Map.merge),修复方式是在收集前过滤掉值为 null 的元素,或用非 null 占位值替代。
排查手段:先按目标键分组并统计 size() > 1 的组,判断冲突来自数据本身还是键提取函数写得过宽(例如漏了租户维度)。
3.5.2 并行流结果错乱
现象:结果条数少于预期,集合内容随机缺失或重复,且不抛异常,因此往往直到数据核对时才被发现。
// 错误:ArrayList 被多线程并发 add
List<Order> result = new ArrayList<>();
orders.parallelStream()
.filter(Order::isPaid)
.forEach(result::add);
修复(按优先级):
// 修复一:用 collect 收集(推荐,每个分片独立容器)
List<Order> result = orders.parallelStream()
.filter(Order::isPaid)
.collect(Collectors.toList());
// 修复二:必须使用 forEach 副作用时,改用并发容器
List<Order> r2 = new CopyOnWriteArrayList<>();
orders.parallelStream().filter(Order::isPaid).forEach(r2::add);
// 修复三:计数场景使用 LongAdder 而非 long 或 AtomicLong 累加
LongAdder counter = new LongAdder();
orders.parallelStream().filter(Order::isPaid).forEach(o -> counter.increment());
需要澄清:并发容器只保证单个操作的原子性,复合操作仍然有竞态,if (map.containsKey(k)) map.put(k, v) 应改写为 computeIfAbsent 或 merge(见 Java 集合框架实现原理 第 4 节)。CopyOnWriteArrayList 每次写入复制整个数组,在元素量级大时写放大严重,只适合写极少、读为主的场景。
3.5.3 并行流中调用远程服务导致线程池打满
现象:接口整体变慢,多个不相关的功能同时退化;线程列表中出现大量 ForkJoinPool.commonPool-worker-N 处于网络等待;日志显示 CompletableFuture 的异步任务与并行流任务同时排队。
// 错误:在并行流中做远程调用
List<Detail> details = ids.parallelStream()
.map(this::callRemoteService) // 每次调用阻塞数百毫秒
.toList();
原因:并行流在公共池中执行远程调用,阻塞的工作线程既不能处理本流的其余分片,也不能响应公共池上的其他任务。公共池是全局单例,一个功能的阻塞会放大为整个 JVM 的退化。
修复方向:
// 方案一:改回顺序流,或用专用线程池控制并发
List<Detail> details = ids.stream()
.map(this::callRemoteService)
.toList();
// 方案二:交给专用线程池 + CompletableFuture 编排,带超时与降级
ExecutorService io = new ThreadPoolExecutor(
16, 16, 0L, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(256),
new ThreadPoolExecutor.CallerRunsPolicy());
List<CompletableFuture<Detail>> futures = ids.stream()
.map(id -> CompletableFuture
.supplyAsync(() -> callRemoteService(id), io)
.orTimeout(2, TimeUnit.SECONDS)
.exceptionally(ex -> Detail.fallback(id)))
.toList();
List<Detail> details2 = futures.stream().map(CompletableFuture::join).toList();
排查顺序:先确认线程池归属(线程名)→ 确认是否存在阻塞调用 → 检查是否有多个组件共用公共池 → 评估是否改用专用执行器。线程栈与线程池状态的采集与判读方式见 Java 应用诊断与部署调优。
3.5.4 Stream 复用导致的异常
现象:IllegalStateException: stream has already been operated upon or closed。
// 错误:同一 Stream 对象被消费两次
Stream<Order> stream = orders.stream().filter(Order::isPaid);
long count = stream.count();
List<Order> paid = stream.sorted(Comparator.comparing(Order::getId)).toList(); // 抛异常
修复:把"操作序列"封装为方法,每次调用产生新流。
private Stream<Order> paidOrders() {
return orders.stream().filter(Order::isPaid);
}
long count = paidOrders().count();
List<Order> paid = paidOrders().sorted(Comparator.comparing(Order::getId)).toList();
需要把流作为参数传递或保存时,使用 Supplier<Stream<T>> 而不是 Stream<T>。
3.5.5 惰性未执行(缺少终止操作)
现象:代码不报错但没有任何效果;日志无输出;集合没有被填充。
// 错误一:只有中间操作
orders.stream()
.filter(Order::isPaid)
.map(this::toDto); // 缺少终止操作,什么都不会发生
// 错误二:把 peek 当收集使用
List<Order> result = new ArrayList<>();
orders.stream().peek(result::add); // 仍然没有终止操作
修复:明确写出终止操作(collect、toList、count、forEach、anyMatch、reduce)。反过来的情况同样需要注意:源已知大小时,count() 存在直接返回大小的短路优化,中间操作可能根本不执行,因此不能依赖 peek 或 map 中的副作用"顺带完成"某些工作。
3.5.6 Optional 误用导致空指针
现象:NoSuchElementException(来自 Optional.get())或 NullPointerException(来自 Optional.of(null))。
// 错误一:直接 get
String city = findCity(orderId).get();
// 错误二:of 传入可能为 null 的值
Optional<String> name = Optional.of(maybeNullName); // 立即 NPE
// 错误三:把 Optional 当字段
class UserDto {
private Optional<String> nickname; // 未实现 Serializable,且多一层包装
}
// 错误四:返回 null 的 Optional
Optional<User> find(long id) {
return null; // 比返回 Optional.empty() 更危险
}
修复:
// 修复一:给出缺失语义,而不是让异常决定
String city = findCity(orderId).orElse(DEFAULT_CITY);
// 修复二:边界处使用 ofNullable
Optional<String> name = Optional.ofNullable(maybeNullName);
// 修复三:字段使用可空引用或空对象,Optional 只出现在返回值位置
class UserDto {
private String nickname; // 允许为 null,语义由约定表达
}
// 修复四:绝不返回 null
Optional<User> find(long id) {
return Optional.ofNullable(repository.selectById(id));
}
把 Optional.get()、Optional 作字段、Optional 作参数等写法纳入静态检查规则,可在提交前拦截(见 3.6)。
3.5.7 其他常见错误写法对照
| 现象 | 错误写法 | 修复 |
|---|---|---|
| 无限流挂死 | Stream.iterate(0, i -> i + 1).count() | 加 limit(n),或改用有限源 |
| 并行流取到的元素不符合预期 | parallel().findFirst() | 顺序无关时用 findAny();需要第一个时用顺序流 |
| 并行反而更慢 | 小集合 parallel()、LinkedList 源、管道含 sorted | 改回顺序流;先按 3.4.1 核对条件 |
peek 未按预期执行 | 用 peek 承载副作用 | 改写为 map / forEach,或先 collect 再处理 |
| 数值聚合结果异常 | map(o -> o.getAmount()).reduce(0, Integer::sum) 混用类型 | 用 mapToInt/mapToDouble + sum(),或 Collectors.summingXxx |
| 并行拼接顺序不定 | parallel().map(..).reduce("", String::concat) | 顺序流 + Collectors.joining |
分组后键为 null 抛 NPE | groupingBy(o -> o.getCity()) 且存在空城市 | 分类函数中先做占位映射 |
收集时报 NullPointerException | toMap 的值映射返回 null | 过滤空值或使用占位值 |
3.6 编码规范建议
规范的作用是把可机器判定的部分交给工具,把需要判断的部分留给评审。规则分级、增量生效、门禁与重复代码检测的机制见 代码质量与静态分析。
3.6.1 推荐用法
| 类别 | 推荐 |
|---|---|
| 返回值语义 | 可能无值的单值查询返回 Optional<T>;集合与数组返回空集合、空数组 |
| Optional | 只在返回值位置出现;用 orElseGet 表达惰性默认值;用 map/filter/flatMap 替代 isPresent + get |
| Lambda | 方法体保持单表达式;超过两三行的逻辑提取为具名方法 |
| 方法引用 | 仅当方法与目标签名完全对应且方法名自带语义时使用 |
| 管道编排 | 每行一个阶段;先过滤后映射;复杂聚合封装为返回 Stream 的具名方法 |
| 收集 | 集合类结果一律用 collect;分组统一用 groupingBy 加下游收集器 |
| 并行 | 仅在数据量大、纯 CPU、源可拆分、顺序无关且有测量依据时使用 |
3.6.2 禁止用法
| 类别 | 禁止 |
|---|---|
| 并行流 | 在管道中调用远程服务、数据库查询、文件 IO 等阻塞操作 |
| 并行流 | 在 forEach 中向非并发集合累加或修改外部状态 |
| 并行流 | 未经测量即把热点路径或大范围代码改为并行 |
| Stream | 缓存 Stream 对象重复消费;对同一 Stream 做两次终止操作 |
| Stream | 在管道中承载业务副作用(写库、发消息、改外部变量);用 peek 执行业务逻辑 |
| Stream | 缺少短路操作的无限流(count、forEach、sorted) |
| reduce | 使用可变对象作为 identity;用不满足结合律的运算做并行归约 |
| Optional | 作为字段、方法参数、集合元素;不判断即调用 get();返回 null 的 Optional |
3.6.3 评审要点
按以下顺序检查,先正确性后表达:
- 空值与缺失:返回值语义是否一致,是否存在
Optional.get()未处理的路径; - 共享状态:管道与 Lambda 是否读写外部可变状态,并行流中是否存在共享容器;
- 副作用位置:
peek、forEach中是否有业务副作用; - 并行判断:出现
parallel()或parallelStream()时,是否有测量依据,是否含阻塞调用或有状态操作; - 可读性:管道长度、命名、
flatMap与多级分组的复杂度; - 重复:同一段管道是否在多个方法中重复,能否提取为具名方法。
3.6.4 与团队规范的衔接
- 把"禁止
Optional作字段与参数""禁止在并行流中调用远程服务""禁止在forEach中修改外部集合"等条目写入静态分析规则集(缺陷模式类规则,设为阻断级),让它们在提交前被机器拦截,而不是依赖评审记忆; - 规则集变更与业务代码变更分开提交,并在团队内同步(配置版本受控的做法见 代码质量与静态分析);
- 若团队已有更具体的框架约定(统一集合工具类、统一禁用并行流等),以团队约定为准,本节清单只作为最低要求。
四、总结
函数式特性在 Java 中的定位可以归结为一句:用 SAM 接口承载 Lambda,用管道承载批量数据变换,用 Optional 承载"可能没有值"的返回值。
原理层面的核心事实:
- Lambda 是 SAM 接口的实例。它没有自己的类型,靠目标类型确定;编译为
invokedynamic,this指向外围实例,不引入新作用域。类型推断与重载决议的冲突需要用显式强转解决。 - 捕获是值捕获。局部变量必须有效 final,因为 Lambda 复制的是值而不是变量;捕获会延长被捕获对象的生命周期,且只保证引用不变——共享可变对象的并发访问仍然需要同步。
- Optional 是返回值容器。它的价值是在类型层面标注缺失,一旦出现在字段、参数、集合元素中就只剩成本;
orElse与orElseGet的求值时机差异是高频错误来源。 - Stream 是惰性的管道。中间操作只构建阶段,终止操作才触发元素逐个穿过管道;有状态操作(
sorted、distinct、limit)会引入缓冲与屏障,破坏流式特性;Stream 只能消费一次。 - 归约要求结合律。
reduce的identity必须是单位元且不可变,否则并行结果不确定;集合类结果的正确工具是collect,其Collector由 supplier、accumulator、combiner、finisher 与特征标志构成。 - 并行流运行在全局公共池上。拆分能力由源的
Spliterator决定;共享可变状态会被静默破坏,阻塞调用会拖慢整个 JVM;并行只在数据量大、纯 CPU、源可拆分、顺序无关时才是优化。
工程层面的结论:
- 改写的目的首先是表达意图。管道把"做什么"与"怎么做"分离;若改写后没有让意图更清晰,保留循环是正确选择。
- 聚合尽量下推到数据库。把全量数据拉到应用内存再聚合,会同时付出传输、对象创建、GC 与内存峰值的代价。
- 并行是需要论证的决定。先测量,再逐条核对适用条件,最后才考虑线程池隔离;隔离本身会引入线程管理、嵌套并行与关闭语义的新问题。
- 把可判定的写法交给工具。空值语义、
Optional的使用范围、并行流中的阻塞调用与副作用,都可以通过静态规则在提交前拦截。
Java 的函数式风格是一组工具,不是一种必须贯彻的主义。它的边界由数据量、控制流复杂度与并发模型共同决定,认清这些边界比熟练调用 API 更能决定代码在真实系统中的表现。