内容总览

Java 函数式编程与 Stream 思维导图

一、起源:集合处理中的三类摩擦

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。

三条结论:

  1. 有效 final 只保证引用的不变性,不保证线程安全;
  2. 捕获对象如果是可变容器,并发访问仍需同步或改用并发容器;
  3. 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,原因有三:

  1. Optional 自身是引用,仍可能为 null;返回 null 的 Optional 比返回 null 更危险,因为调用方已经假设容器非空;
  2. 它增加一个包装对象与一次间接取值,出现在字段、参数、集合元素时会放大分配与调用成本;
  3. 它未实现 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+) 结果加工与双路归并

必须记住的语义点:

  1. groupingBy 的返回类型默认是 HashMap,顺序不确定;需要稳定顺序时使用三参版本传入 LinkedHashMap::new,需要按键排序传入 TreeMap::new。
  2. groupingBy 的分类函数不允许返回 null,否则抛 NullPointerException;需要保留未知分组时应先把键映射成占位值(如 "UNKNOWN")。
  3. partitioningBy 与 groupingBy 的差别在空分组:前者结果中必然同时包含 true 与 false 两个键(即使某一侧为空容器),后者不产生空分组。
  4. toMap 遇到重复键默认抛 IllegalStateException: Duplicate key,必须显式提供合并函数;合并函数的两个参数是(已存在的值, 新值),顺序容易记错。
  5. toMap 的值不允许为 null:内部使用 Map.merge,而 merge 拒绝 null 值,会抛 NullPointerException。
  6. 下游收集器是分组的核心用法: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 适用条件

四条同时成立时才考虑并行:

  1. 数据量足够大:元素数与单元素工作量的乘积要能覆盖任务拆分、提交与合并的开销。数千到数万元素以下通常没有收益;只做一次简单比较的场景,百万级也可能不如顺序流。
  2. 元素处理相互独立:没有共享可变状态,处理顺序不影响结果。
  3. 源可高效拆分:参照 2.8.2 的表格。
  4. 不在意顺序:需要顺序时使用 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 并行下的度量方法

并行收益必须实测,步骤与要点:

  1. 建立基线:记录顺序流版本的吞吐、延迟分布、CPU 使用与 GC 分配速率,采集与对比流程参照 性能测试与基线 的基线采集与回归对比方法。
  2. 一次只改一个变量:仅改变"顺序/并行",使用相同的预热轮次与测量轮次,取中位数作为结论。
  3. 确认线程归属:线程列表中出现 ForkJoinPool.commonPool-worker-N 说明正在使用公共池;若自定义池生效,应出现对应的池线程名。工作线程长期处于阻塞状态,说明管道中存在阻塞调用(对应 3.5.3)。
  4. 观察 CPU:并行有效的标志是多核同时繁忙且总耗时下降;若 CPU 未上升而耗时不变,说明拆分失败(源不可拆分或任务量太小)。
  5. 观察内存与 GC:分片、缓冲(有状态操作)与合并阶段会引入额外分配;若 GC 时间上升抵消了收益,应放弃并行。
  6. 避免误测:测量包含预热过程时结果不可比;未消费的中间结果可能被优化掉,需确保最终结果被真正使用。

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 评审要点

按以下顺序检查,先正确性后表达:

  1. 空值与缺失:返回值语义是否一致,是否存在 Optional.get() 未处理的路径;
  2. 共享状态:管道与 Lambda 是否读写外部可变状态,并行流中是否存在共享容器;
  3. 副作用位置:peek、forEach 中是否有业务副作用;
  4. 并行判断:出现 parallel() 或 parallelStream() 时,是否有测量依据,是否含阻塞调用或有状态操作;
  5. 可读性:管道长度、命名、flatMap 与多级分组的复杂度;
  6. 重复:同一段管道是否在多个方法中重复,能否提取为具名方法。

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 更能决定代码在真实系统中的表现。