Java 函数式编程精讲:从 Stream 源码说起 ------ 用真实源码学懂函数式思维
读 Stream 源码时你会发现一个有趣的现象:JDK 自己就是函数式编程的重度用户------
map把函数当参数收,Function.andThen用 lambda 实现 lambda 的组合,peek是全源码里唯一"故意留的副作用出口"。想学函数式编程(FP),没有比 Stream 源码更好的中文教材了:它足够小、足够真、而且你已经在用。本文是本系列第四篇(前作:《Java Stream 从入门到深入》、《Java Stream 实现原理:JDK 21 源码解析》、《Java 泛型精讲:从 Stream 源码说起》),目标是把函数式编程的核心思想(而非 Haskell 理论体系)讲透:函数是一等公民、纯函数与副作用、不可变性、组合、惰性、fold、flatMap。
版本基线:本文基于 JDK 21(LTS)源码(Temurin 21.0.9 的
src.zip) ,源码引用来自java.base/java/util/function/、java.base/java/util/stream/与java.util.Optional;文中的"实测"结论均在 JDK 21 下编译运行验证。OpenJDK 源码采用 GPLv2+Classpath Exception 许可,文中仅摘录关键片段并加注解。范围边界:不讲范畴论、不讲 Haskell/Scala 的类型类与单子理论、不讲响应式流------只讲"Java 工程师用得上的函数式"。第 8 章会以"惊鸿一瞥"的方式给 monad 一个直觉,够用即可。
目录
- 怎么读这篇
- 函数式编程是什么
- 函数是一等公民
- 纯函数与副作用
- 组合与高阶函数
- 不可变性
- 惰性求值
- [reduce 与 fold](#reduce 与 fold "#7-reduce-%E4%B8%8E-fold")
- [flatMap 与链式上下文](#flatMap 与链式上下文 "#8-flatmap-%E4%B8%8E%E9%93%BE%E5%BC%8F%E4%B8%8A%E4%B8%8B%E6%96%87")
- [Java 函数式的边界与心法](#Java 函数式的边界与心法 "#9-java-%E5%87%BD%E6%95%B0%E5%BC%8F%E7%9A%84%E8%BE%B9%E7%95%8C%E4%B8%8E%E5%BF%83%E6%B3%95")
- 总结速查表
0. 怎么读这篇
你将带走四样东西:
- 函数式编程的完整心智模型:一等公民、纯函数、副作用、不可变、组合、惰性、fold------每个概念都能落到 Stream 源码的具体行上;
- 一眼看懂
Function<? super T, ? extends R>、Function<T, R>.andThen(...)这类签名背后的函数式语义(与《泛型精讲》互为表里); - 判断"我的代码够不够函数式"的实践标准,以及 Java 的合理边界(不必为了纯而纯);
- 三个动手实验,把抽象概念跑成可见的输出。
前置知识:
| 需要 | 不需要 |
|---|---|
| Java 基础:lambda、方法引用会写会用 | Haskell/Scala/F# 任何函数式语言 |
| 用过 Stream 的 map/filter/collect(本系列前作最佳) | 范畴论、单子、类型类等理论 |
| 读过《泛型精讲》第 3 章更佳(PECS 会复用) | 响应式编程经验 |
讲解约定 (与系列一致):每个概念四步走------① 现象 (源码签名/你见过的行为)→ ② 白话原理 (类比先行,此步不出现未解释的术语)→ ③ 源码求证 (逐行注解)→ ④ 实测复核(输出/报错原文)。每章收口"本章一句话";⚠️ 标易错与代价,💡 标设计动机;"(进阶,可跳过)"段落可自行降载。
贯穿全文的类比------菜谱卡片 :函数式的世界里,"做法"被写成一张张菜谱卡片(函数值),卡片可以传递、装订、拼接(一等公民、组合),标准菜谱保证同样食材必出同样菜(纯函数/引用透明),菜谱不等于做菜(惰性),点单才开火(求值)。前作《从入门到深入》的"命令式像教人做菜、声明式像点菜",本文把"菜谱"本身拆开看。
本章一句话:带着"菜谱卡片"的类比上路,每个函数式概念都在 Stream 源码里找到实物。
1. 函数式编程是什么
1.1 现象:一行源码里的"函数当参数"
先看《实现原理》篇 2.4 的老朋友------map 的实现核心(ReferencePipeline.java):
java
// ------ 摘自 ReferencePipeline.java(map 的 opWrapSink 内,节选)------
@Override
public void accept(P_OUT u) {
downstream.accept(mapper.apply(u)); // ① 把传进来的"函数"应用到元素上
}
// ② mapper 是方法参数------函数被当成了"值"在方法间传递
① 处的 mapper 不是数据、不是字符串,而是一段行为 (转换规则),它作为参数传进来、在需要时被"应用"。把行为当参数传来传去------这就是函数式编程最外层的特征。
1.2 白话原理:两种思维的根本差异
回顾系列第一篇的对照(教人做菜 vs 点菜),现在把两种思维的根本差异说透:
- 命令式(imperative):关注"怎么做"------一步步修改状态(建变量、循环、赋值)。世界的模型是"内存里的格子在变化"。
- 函数式(functional) :关注"是什么"------用变换 从旧值造新值(
f(x)出新值,旧值不动)。世界的模型是"值的流动与变换"。
一个求和的对照(实测 D8,JDK 21):
java
// 命令式:靠"可变的累加格子"推进
int sum = 0;
for (int x : List.of(1, 2, 3, 4)) { sum += x; } // 每步改写 sum
// 函数式:折叠------一串值"塌缩"成一个值,没有改写任何变量
int sum2 = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum); // 10
两段代码结果相同,但世界观不同:前者的核心是状态变化 ,后者的核心是值的变换 。函数式编程(FP)就是后一种世界观下的系统方法论,它有三板斧:
- 函数是一等公民------函数可以当参数、当返回值、当变量(第 2 章);
- 纯函数------同样的输入必得同样的输出,且不修改外界(第 3 章);
- 不可变性------数据造出来就不改,要改就造新的(第 5 章)。
三板斧带来两个工程红利:可组合 (小函数拼大逻辑,第 4 章)和可并行(无副作用 → 放心拆开跑,第 3 章末)。Stream 正是把这套世界观搬进 Java 的载体。
💡 为什么 Java 需要 Stream 来承载 FP?因为 Java 的语法主体是命令式的(语句、赋值、循环),FP 需要"函数当值 + 无副作用的表达空间"------Stream API + lambda 提供了这个空间。也正因如此,Java 的函数式是库层面的(第 9 章讲它的边界)。
本章一句话:函数式 = 用变换造值的世界观(对比命令式改状态),三板斧是一等公民、纯函数、不可变性------map 把函数当参数收,就是这套世界观的门面。
2. 函数是一等公民
2.1 现象:Java 里"函数"长什么样
Stream 源码里到处是这类参数:map(Function<...>)、filter(Predicate<...>)、forEach(Consumer<...>)、reduce(BinaryOperator<...>)。它们的类型都指向 java.util.function 包的四个基础接口:
java
// ------ 摘自 java/util/function/ 各接口声明 ------
@FunctionalInterface
public interface Function<T, R> { R apply(T t); } // ① 一进一出:转换
@FunctionalInterface
public interface Predicate<T> { boolean test(T t); } // ② 一进一布尔:判定
@FunctionalInterface
public interface Consumer<T> { void accept(T t); } // ③ 一进无出:消费
@FunctionalInterface
public interface Supplier<T> { T get(); } // ④ 无进一出:生产
每个接口只有一个抽象方法 (术语叫 SAM:Single Abstract Method)。这是刻意设计:只有一个方法的接口,才能让 lambda "对号入座"。
2.2 白话原理:一等公民 = 函数是"值"
"一等公民(first-class)"的白话标准就三条:能当参数传、能当返回值吐、能存进变量。菜谱类比:菜谱卡片(函数)可以递给厨师(参数)、可以打包进礼盒(返回值)、可以放进抽屉(变量)。
Java 的落地方式------lambda 表达式 就是"匿名函数"的语法糖,方法引用是更短的糖:
java
// 同一个"求长度"行为的四种写法(实测 D1,JDK 21 全部编译通过)
Function<String, Integer> f1 = String::length; // 方法引用:非绑定实例方法
Function<Integer, String> f2 = String::valueOf; // 方法引用:静态方法
String s = "hello";
Supplier<Integer> f3 = s::length; // 方法引用:绑定实例方法
Supplier<List<String>> f4 = ArrayList::new; // 构造器引用
// 运行输出:3,9,5,ArrayList
四种方法引用(类::静态方法、实例::方法、类::实例方法、类::new)只是写法 ,本质都是"把一段行为装进 SAM 接口的实例"。x -> x + 1 同理------编译器按目标类型(SAM 接口)自动完成"函数 → 对象"的包装,术语叫 SAM 转换。
2.3 源码求证:@FunctionalInterface 与高阶函数
(1)@FunctionalInterface 是编译器的契约。 注解本身不改变行为,但加了它,编译器会强制 接口只有一个抽象方法(再加第二个就编译失败)------防止接口"长胖"后 lambda 全体失效。Function/Predicate/Consumer/Supplier/UnaryOperator 全部带这个注解(见 2.1 摘录)。
(2)函数可以加工函数------高阶函数。 "高阶函数(higher-order function)"指参数或返回值是函数的函数。实测 D2(JDK 21):
java
// 高阶函数:吃进一个函数,返回一个"做两遍"的新函数
static Function<Integer, Integer> applyTwice(Function<Integer, Integer> f) {
return x -> f.apply(f.apply(x)); // ① 返回值是 lambda------函数被"造"了出来
}
// 用法:applyTwice(inc, 5) → inc(inc(5)) → 7
① 处尤其值得停一秒:applyTwice 生产了一个函数(返回 lambda)------函数不仅能当参数进,还能当结果出。菜谱加工厂的类比:输入一张"加 1"的菜谱,输出一张"加两次 1"的新菜谱。
(3)源码里的实锤:Function.andThen 用 lambda 实现组合。 这是本文的"镇文之宝"之一------看 JDK 怎么定义"函数的串联"(Function.java):
java
// ------ 摘自 Function.java(andThen 完整体)------
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t)); // ① 先跑自己 apply,再跑 after.apply
}
// ------ 摘自 Function.java(compose 完整体)------
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v)); // ② 先跑 before,再跑自己
}
函数的组合本身就是一个返回 lambda 的函数------高阶函数的教科书实例。①② 的差别只在执行顺序(第 4 章专门拆)。
(4)类型层面的小彩蛋 :UnaryOperator<T> extends Function<T, T>(UnaryOperator.java)------"输入输出同型的函数"起了个短名,和《泛型精讲》7.4 的 BinaryOperator<T> extends BiFunction<T,T,T> 是同一手法:用继承做"类型别名"。
本章一句话 :函数式接口(SAM)+ lambda/方法引用让 Java 的函数成为可传递的值;@FunctionalInterface 守住"只有一个方法"的底线;applyTwice 和 Function.andThen 证明函数还能造函数------一等公民 + 高阶函数就位。
3. 纯函数与副作用
3.1 现象:源码里唯一的"副作用出口"
peek 的实现(ReferencePipeline.java,系列的老朋友):
java
// ------ 摘自 ReferencePipeline.java(peek 的 opWrapSink 内,节选)------
@Override
public void accept(P_OUT u) {
action.accept(u); // ① 旁路:执行你给的"副作用动作"
downstream.accept(u); // ② 原样下推,与 ① 无关
}
对比 filter 的 predicate.test(u)(纯判定)和 map 的 mapper.apply(u)(纯变换),peek 的 action 是 JDK 故意留的口子 ------它的 Javadoc apiNote 原话:"mainly to support debugging"(主要为调试而设)。为什么只有调试能用?因为它是副作用。
3.2 白话原理:纯函数 = 标准菜谱
**纯函数(pure function)**的定义就两条:
- 引用透明:同样的输入,永远得到同样的输出(不看表、不掷骰子、不读全局变量);
- 无副作用:不修改任何外部状态(不改参数对象、不写文件、不发请求)。
菜谱类比:标准菜谱是纯的------同样食材必出同样菜,且做菜过程不改变厨房的其他东西;如果菜谱里写"顺便把厨房灯关了",它就混入了副作用,做菜和改厨房状态纠缠在一起。
副作用(side effect)就是"函数干了自己名字以外的事":改共享变量、改传入对象、写日志、调 RPC。peek 的 action、forEach 的 Consumer、Collectors.toList() 里的 List::add 都是副作用------差别在于圈在哪、可控不可控(第 9 章的心法)。
3.3 源码求证:Java 对"纯度"的两道防线
防线一:lambda 捕获规则------局部变量必须 effectively final。 这是 Java 语言层面强制的一小块纯度。反例实测(E1,预期编译失败):
java
int count = 0;
Stream.of(1, 2, 3).filter(x -> { count++; return x > 1; }); // ❌ 编译失败
编译器报错原文(JDK 21 实测):
makefile
错误: 从 lambda 表达式引用的本地变量必须是最终或最终有效的
为什么 Java 要封这条? 如果 lambda 能改捕获的局部变量,闭包在并行/延迟执行时的语义会灾难性地混乱(变量生命周期、线程可见性)。Java 的选择:干脆禁止 ------想累积状态?用 AtomicInteger(显式的可变容器,把自己的"不纯"写在脸上)。这条规则就是《从入门到深入》13 章坑 2 的底层原因。
防线二:并行安全靠纯度说话。 副作用在并行流下的代价,实测 D6(JDK 21,10000 个元素):
java
List<Integer> unsafe = new ArrayList<>();
IntStream.range(0, 10000).parallel().forEach(unsafe::add); // 副作用:往外部集合写
// 实测输出:元素数 9748(应为 10000)------数据在并行竞态中丢失!
List<Integer> safe = IntStream.range(0, 10000).parallel().boxed()
.collect(Collectors.toList()); // 换成 collect
// 实测输出:10000 ✓
同样一万次写入,副作用写法丢了 252 个元素(ArrayList 非线程安全,并发扩容竞态);collect 让框架在内部安全合并(《实现原理》篇 7.4 的 combiner 机制),一次不丢。纯函数(不改外部状态)没有这个竞态面------这就是"纯度 → 可并行"的因果链。
💡 进阶(可跳过):
List::add作为收集器的 accumulator 也是副作用(改容器),为什么它安全?因为它的副作用被框架圈养 了------每个线程攒自己的容器、最后 combiner 合并(可变约简,见《实现原理》7.3)。FP 不是消灭副作用,而是把它压缩到受控的边界上------这是 Java 工程实践里最重要的一条 FP 认知。
本章一句话:纯函数 = 引用透明 + 无副作用(标准菜谱);Java 用 effectively-final 规则强制闭包纯净(报错原文为证),副作用在并行下实测丢数据(9748/10000)------纯度是可并行的前提,副作用要圈在受控边界里。
4. 组合与高阶函数
4.1 现象:两个顺序不同的"函数串联"
Function 的 andThen 与 compose(第 2 章看过源码)语义差别只在顺序。实测 D3(JDK 21,plus1 = x+1,times2 = x*2,输入 3):
java
plus1.andThen(times2).apply(3); // 先 +1 再 ×2 → (3+1)*2 = 8
plus1.compose(times2).apply(3); // 先 ×2 再 +1 → 3*2+1 = 7
// 实测输出:andThen → 8 | compose → 7
4.2 白话原理:组合 = 拼菜谱
高阶函数的两大用途:加工函数 (applyTwice 那样造新函数)和拼接函数(把两张菜谱装订成一张流水菜谱)。拼接有两种装订顺序:
f.andThen(g):先 f 后 g("我做完再交给你");f.compose(g):先 g 后 f("你先做我再接手")。
记忆法:andThen 的宾语是"下一步",compose 的宾语是"上一步"------看方法名的主语是谁。
4.3 源码求证:组合家族全景
JDK 为每个 SAM 接口都配了组合方法,实现清一色是"返回 lambda":
java
// ------ 摘自 Predicate.java(and)------
default Predicate<T> and(Predicate<? super T> other) {
return (t) -> test(t) && other.test(t); // 判定的与组合
}
// ------ 摘自 Consumer.java(andThen)------
default Consumer<T> andThen(Consumer<? super T> after) {
return (T t) -> { accept(t); after.accept(t); }; // 消费的顺序执行
}
再加上泛型篇章的 BinaryOperator(同型二元函数)------组合家族齐了。注意 andThen 的签名 Function<? super R, ? extends V>:PECS 又出现了(前函数的输出 R 是后函数的输入,宽进宽出保证可拼)。
4.4 Stream 链 = 组合的流水线形态
真正的深处在 Stream 的链式调用里。看一个等价性实验(实测 D4,JDK 21):
java
List.of(1, 2, 3).stream().map(plus1).map(times2) // 两次 map
List.of(1, 2, 3).stream().map(plus1.andThen(times2)) // 一次 map(组合后)
// 两者输出均为 [4, 6, 8] ------ map(f).map(g) ≡ map(f.andThen(g)) ✓
这不是巧合。《实现原理》篇 3.4 的 wrapSink 把每个操作包成 Sink 壳套壳------链式调用的执行结构就是函数组合 :filter 壳 ∘ map 壳 ∘ 收货台,元素穿过它们等价于 收货台(map(filter(x)))。从函数式的视角重看那张 Sink 链图:
less
Stream 链: x → [filter] → [map f] → [map g] → 容器
函数组合: x → g(f(filter(x))) → 容器
// 同一件事:流水线写法(OOP 语法)表达的就是函数的组合(FP 语义)
💡 这回答了一个深层问题:"Stream 到底是 OOP 还是 FP?"------语法是 OOP 的链式调用,语义是 FP 的函数组合。JDK 用 OOP 的瓶子装了 FP 的酒。
本章一句话:组合把小函数拼成大逻辑(andThen 先己后人、compose 先人后己),JDK 的组合方法全是"返回 lambda"的高阶函数;Stream 链的 Sink 套娃就是函数组合的流水线形态------map(f).map(g) ≡ map(f.andThen(g)) 实测成立。
5. 不可变性
5.1 现象:三个"不改"的证据
函数式世界的第三板斧:数据造出来就不改。Stream 家族的三个证据:
- Stream 不改源数据 (《从入门到深入》3.②):
list.stream().map(x -> x*10)跑完,list 还是原样; - Optional 的变换返回新盒子(源码见下);
- 不可变收集的显式 API :
toUnmodifiableList()、Stream.toList()(JDK 21 均可用)。
5.2 白话原理:值语义 vs 可变状态
不可变(immutable) :对象一旦造好,状态永不改变;"修改"= 造一个新对象。菜谱类比:做菜不往原食材袋里塞东西------成品装新盘子端出去,原袋封存。
为什么要这么麻烦?因为可变状态是推理的敌人 :两个线程共享一个可变对象 → 竞态(3.3 实测的丢数据);一个对象被十处代码改过 → 没人知道它现在为什么是这个值。不可变数据天然线程安全、天然可追溯------不需要锁就能随便共享。
5.3 源码求证:Optional.map 的"造新值"模式
java
// ------ 摘自 Optional.java(map 完整体)------
public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (isEmpty()) {
return empty(); // ① 空盒还是空盒(不改自己)
} else {
return Optional.ofNullable(mapper.apply(value)); // ② 造一个新盒子返回
}
}
全程没有一处 this.value = ... ------map 从不修改自己,只返回新的 Optional。空值传播的实测(D7,JDK 21):
java
Optional<String> maybe = Optional.empty();
maybe.map(String::toUpperCase).orElse("(空,没炸)");
// 实测输出:(空,没炸)------空盒沿链传播,不抛异常
String n = null; n.toUpperCase();
// 实测输出:NullPointerException------裸 null 的世界里到处是雷
Optional 的价值一半在"可能没有"的语义,一半在迫使你用变换代替解包修改------它是把 FP 的不可变风格带进判空场景的小容器。
5.4 代价与折中:函数式外壳下的命令式内核
诚实的深度在这里。不可变不是免费的 :每步"修改"都造新对象 → 分配与 GC 开销;原地修改(sum += x)在性能敏感场景就是更快。JDK 的折中方案,看 Collectors.toList()(Collectors.java):
java
// ------ 摘自 Collectors.java(toList,节选)------
return new CollectorImpl<>(ArrayList::new, List::add, // ① 容器是可变的 ArrayList
(left, right) -> { left.addAll(right); return left; }, CH_ID);
① 处的 List::add 是受控的可变性 :流水线对外呈现纯变换(输入流 → 输出新 List),内核用可变容器攒性能。类比:厨房后厨乱归乱,端出去的盘子是新的。函数式是对外契约,命令式是内部优化------这是工程上"纯度"的真实形态(第 9 章的心法会收拢这条)。
⚠️ 需要对外保证不可变时,用
toUnmodifiableList()/Stream.toList()(产物不可变);需要可变产物时用toCollection(ArrayList::new)------把可变性写成显式选择,而不是意外(《从入门到深入》8.1 的"精确说明")。
本章一句话:不可变 = 修改即造新值(Optional.map 全程不改自己),换来免锁共享与可推理性;JDK 用"对外纯变换、内核可变容器"折中性能------可变性要成为显式选择。
6. 惰性求值
6.1 现象:菜谱不等于做菜
《实现原理》篇 2.4 的实验:list.stream().map(...) 跑完什么都没发生------map 只是 new StatelessOp(...) 挂了个节点。而 peek(...).count() 连 peek 都不执行(SIZED 优化直接抄答案)。Stream 链是"计算的描述",不是"计算本身"。
6.2 白话原理:描述即值
函数式语言(Haskell)把"惰性"推到极致:表达式在需要之前不求值 。菜谱类比:写下"红烧肉"三个字不等于做肉------菜谱是描述,点单(需要结果)才开火。
Java 的版本是有限惰性 :中间操作(map/filter/...)只搭描述(Sink 链),终结操作(collect/count/...)才驱动求值。惰性的三个工程红利:
- 短路 :
findFirst只看够用的元素(anyMatch找到即停)------"按需计算",不浪费; - 融合 :一次遍历穿全链,无中间集合(
copyInto的forEachRemaining); - 优化空间 :账本(StreamOpFlag)可以让
count()直接抄答案、已排序的sorted()直接跳过。
6.3 源码求证:描述在哪里、点火在哪里
java
// ------ 摘自 ReferencePipeline.java(map 的返回体,节选)------
return new StatelessOp<P_OUT, R>(this, ...) { ... }; // ① 只是构造"描述节点"
// ------ 摘自 AbstractPipeline.java(evaluate,节选)------
if (linkedOrConsumed) throw new IllegalStateException(MSG_STREAM_LINKED);
linkedOrConsumed = true;
return terminalOp.evaluateSequential(this, sourceSpliterator(...)); // ② 终结操作才点火
① 是"写菜谱",② 是"开火"。两者之间隔着任意多的链式调用------描述可以随意组装(便宜),求值只发生一次(昂贵但优化充分)。
6.4 惰性的代价(诚实面)
⚠️ 惰性不全是优点,两个真实的坑(系列前作都踩过):
- 副作用时序不可读 :
peek里的打印/修改在求值时才发生,代码顺序 ≠ 执行顺序(peek(...).count()可能一次都不跑------《实现原理》5.1 实测); - 错误推迟暴露:lambda 里的 NPE 在 collect 时才炸,而不是写代码的地方。
所以调试用 peek 也只该"看",不该"改"(3.1 的 javadoc 界限)。惰性 + 副作用 = 混乱;惰性 + 纯函数 = 优化------这两章的结论在这里合流。
本章一句话:Stream 链是计算的描述(new 节点),终结操作才点火(evaluate);惰性换来短路/融合/优化,代价是副作用时序与错误位置后移------纯函数让惰性只留好处。
7. reduce 与 fold
7.1 现象:一行替代一个循环
Stream.of(1,2,3,4).reduce(0, Integer::sum) ------函数式里出场率最高的操作。它的正式名字叫 fold(折叠):把一串值按规则"塌缩"成一个值。
7.2 白话原理:折叠 = 消灭循环变量
命令式的求和靠可变的累加格子 (sum += x);fold 把"格子"藏进函数的参数传递里:
ini
fold 的过程(左折叠):((0+1)+2)+3)+4 = 10
每一步都是"两个值 → 一个新值"的纯变换,没有任何变量被改写
菜谱类比:一摞食材逐层"合二为一",每层都是一次纯粹的混合,最终出一道菜。fold 是递归思维的迭代化 ------递归版求和 sum(list) = head + sum(tail) 的每一层递归,正好对应 fold 的每一步。
对照三种写法(实测 D8,JDK 21,结果都是 10):
java
// ① 递归(函数式的原型,但 Java 无尾调用优化,深栈会爆)
// ② 循环(命令式:可变格子)
int sum = 0; for (int x : List.of(1,2,3,4)) sum += x;
// ③ fold(函数式:纯变换折叠)
int sum2 = Stream.of(1,2,3,4).reduce(0, Integer::sum);
7.3 源码求证:ReducingSink 的"状态即值"
《实现原理》篇 7.3 精读过 ReduceOps.makeRef,这里看它的函数式解读(节选):
java
// ------ 摘自 ReduceOps.java(makeRef(seed, reducer, combiner) 的 Sink,节选)------
class ReducingSink implements AccumulatingSink<T, U, ReducingSink> {
private U state; // ① 状态是一个"当前值"
@Override public void begin(long size) { state = identity; }
@Override public void accept(T t) {
state = reducer.apply(state, t); // ② 每步用纯函数造新值替换旧值
}
@Override public void combine(ReducingSink other) {
state = combiner.apply(state, other.state); // ③ 并行合并:纯函数合成
}
}
② 是 fold 的本质:状态的演进 = 纯函数的连续应用 。没有 state.add(...) 这类原地修改(那是可变约简/collect 的做法),只有"旧值进、新值出"。③ 的 combiner 必须满足结合律 ------因为并行时折叠的分组顺序不定(减法就不行,《从入门到深入》6.4 实测过结果漂移)。结合律是 fold 可并行的数学条件。
💡 进阶(可跳过):fold 有两种形态------左折叠
foldl(上式)与右折叠foldr(从右往左,对无限流有意义)。Java 的reduce是左折叠语义;Collectors.joining保遇到顺序,本质是有序的可变折叠。知道名字即可,日常开发用不上区分。
本章一句话:fold/reduce 用纯变换的折叠消灭可变循环变量(((0+1)+2)+...),ReducingSink 的 state 替换就是它的源码形态;结合律是可并行的代价线。
8. flatMap 与链式上下文
8.1 现象:返回"流"的函数
flatMap 的签名在《泛型精讲》里出现过,现在换函数式的眼睛读(Stream.java):
java
// ------ 摘自 Stream.java(flatMap 声明)------
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
// │ │
// │ └─ 关键:mapper 吐出的不是值,是"一串值"(Stream)
// └─ 普通的输入
map 的 mapper 吐一个值 ,flatMap 的 mapper 吐一个流------然后这个流被"摊平"进主干流。为什么需要这种"一对多"?
8.2 白话原理:拆包 → 加工 → 摊平
场景:一个订单有多个商品,要"所有订单的所有商品":
java
List<Product> all = orders.stream()
.flatMap(order -> order.getProducts().stream()) // 每个订单展开成商品小流
.collect(Collectors.toList()); // 小流逐个灌进主干,摊平
菜谱类比:map 是"食材拆袋 → 切丝 → 装回一个袋 ";flatMap 是"食材拆袋 → 切丝 → 丝全部摊到案板上"(一袋进、N 丝出,案板上不分袋)。
为什么不直接用 map? 因为 map(order -> order.getProducts().stream()) 的结果是 Stream<Stream<Product>>------套娃的流 (每个元素还是一个"袋")。flatMap 的语义就是"把套娃摊平一层"。
8.3 源码求证:摊平发生在 accept 里
java
// ------ 摘自 ReferencePipeline.java(flatMap 的 opWrapSink 内,节选)------
@Override
public void accept(P_OUT u) {
try (Stream<? extends R> result = mapper.apply(u)) { // ① 每个元素换出一个小流
if (result != null) {
result.sequential().forEach(downstream); // ② 小流的每个元素直接灌给下游
}
}
}
① 每个元素 都调一次 mapper 得到一个小流(try-with-resources 持有它,用完即关------文件句柄安全);② 小流里的元素逐个灌给下游 Sink ------下游完全感觉不到"曾经分过小流",这就是"摊平"的实现。注意它的标志声明是 NOT_SORTED | NOT_DISTINCT | NOT_SIZED(Stream.java/ReferencePipeline.java)------一对多之后,秩序/去重/大小全部失守。
Optional 的同款 (Optional.java,签名差异很有教学价值):
java
// ------ 摘自 Optional.java(flatMap 完整体)------
public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
Objects.requireNonNull(mapper);
if (isEmpty()) {
return empty(); // 空盒传播
} else {
@SuppressWarnings("unchecked")
Optional<U> r = (Optional<U>) mapper.apply(value); // ① 换出的是"盒"不是"值"
return Objects.requireNonNull(r); // ② 不再包一层------防嵌套!
}
}
①② 解释了 map 与 flatMap 的分界 :map 换值后会再包一层 (Optional.ofNullable(...)),所以 mapper 返回 Optional 就会得到 Optional<Optional<...>> 嵌套;flatMap 要求 mapper 直接返回盒子 ,拆开即得,永不嵌套。实测 D7(JDK 21):Optional.of("abc").flatMap(x -> Optional.of(x.length())) → Optional[3](单层)。
8.4 进阶(可跳过):monad 的惊鸿一瞥
函数式理论里,这种"拆包 → 计算 →(可能多个结果)→ 摊平/装回"的模式有个吓人的名字:单子(monad) ,flatMap 就是它的核心操作(Haskell 里叫 bind / >>=)。看两个事实就够了:
Stream和Optional都实现了同构的操作对:map(换值不换包装)+flatMap(换值且摊平包装);- 有了这两个操作,"带包装的值"(可能为空、可能多个)就能在包装内连续计算 而不用层层解包------
Optional的空传播、Stream的链式加工,都是这个模式的实例。
不必学会 monad 的理论 也能写出 flatMap 代码;但理解"map 换值、flatMap 摊平"的分工后,你看任何 X.map/flatMap 的签名(RxJava 的 Observable、CompletableFuture 的 thenApply/thenCompose!)都能秒懂------thenApply = map、thenCompose = flatMap,这就是举一反三。
本章一句话:flatMap 的 mapper 吐"一串值"(流/盒),accept 里换出小流逐个灌下游实现摊平;map 与 flatMap 的分界是"要不要防嵌套";这个"拆包→计算→摊平"模式就是 monad 的直觉------看懂它,CompletableFuture 的 thenApply/thenCompose 也就通了。
9. Java 函数式的边界与心法
9.1 现象:Java 的函数式"是库,不是语言"
Java 8 引入了 lambda 和 Stream,但语言主体仍是命令式(语句、赋值、可变对象是默认值)。对照函数式语言的常见能力,盘点 Java 的缺口与补位(均在 JDK 21 基线内核实):
| FP 常见能力 | Java 21 现状 | 补位 |
|---|---|---|
| 函数一等公民 | ✅ lambda + SAM 接口 | java.util.function |
| 不可变数据默认 | ⚠️ 默认可变(List.of 只是少数) |
List.of/Map.of/record(16+)/toUnmodifiableList |
| 模式匹配 | ⚠️ 有限(switch 模式匹配 21 正式版) |
instanceof 模式(16+)、switch 模式(21) |
| 尾调用优化 | ❌ 无(深递归会爆栈) | 循环化 / reduce(fold)替代递归 |
| 柯里化/部分应用 | ❌ 无语法(只能手工返回 lambda) | applyTwice 式的高阶函数 |
| 类型类/高阶类型 | ❌ 无 | 泛型 + 接口模拟(见《泛型精讲》F-bounded) |
| 惰性求值 | ⚠️ 有限(Stream 链惰性,表达式严格) | Stream / Supplier(如 orElseGet) |
⚠️ 这张表的正确读法不是"Java 不行",而是"Java 选了务实路线":可变默认、命令式主体保证了可读性与生态兼容(和《泛型精讲》5.5"擦除换兼容"是同一种哲学),FP 能力以库的形式按需取用。
9.2 白话原理:函数式核心 + 命令式外壳
工程上最实用的 FP 姿势,不是"把 Java 写成 Haskell",而是分层:
python
命令式外壳(薄薄一层):IO、日志、数据库、收集结果------副作用圈在这里
↓ 只传值进出
函数式核心(厚厚的业务):纯函数的变换与组合------map/filter/reduce/自写纯方法
菜谱类比:厨房(副作用:火、水、开关)围着菜谱(纯变换)转------菜谱本身保持纯净,脏活累活交给厨房的边界设施。《实现原理》篇的 Sink 链就是这个结构的范本:链上每个 accept 是纯变换,副作用只在收货台(collect 攒容器)和 peek(调试)两处。
9.3 实践清单:五条可执行的建议
- lambda 保持纯:不改捕获变量(编译器已拦)、不改参数对象、不在 map/filter 里调 RPC/写库------业务规则进 lambda,副作用挪到 collect/forEach 的边界;
- peek 只看不改 :调试观察可以,
peek(s -> s.setXxx(...))禁止(《从入门到深入》13 章坑 3 的源码级原因见 3.1); - collect 优于 forEach+add:并行安全由框架合并保证(3.3 实测的 9748 教训);
- 可变性显式化 :要不可变用
toUnmodifiableList()/List.of(),要可变用toCollection(ArrayList::new)------别让"可变"成为意外; - 组合优于巨型 lambda :一个 lambda 超过三行就抽成命名方法再引用(
map(this::extractName))------命名即文档,组合即复用(第 4 章)。
本章一句话:Java 的函数式是"库而非语言"(缺口清单在上),正确姿势是函数式核心 + 命令式外壳;五条清单(lambda 保持纯、peek 只看不改、collect 优于 forEach、可变性显式化、组合优于巨 lambda)就是日常的执行标准。
10. 总结速查表
概念 → Stream 源码实例
| 函数式概念 | Stream 源码实例 | 章节 |
|---|---|---|
| 一等公民 / SAM | Function/Predicate/Consumer/Supplier 四件套 |
2 |
| lambda / 方法引用 | mapper.apply(u)、String::length 四种写法 |
2 |
| 高阶函数 | applyTwice、Function.andThen(返回 lambda) |
2、4 |
| 纯函数 / 引用透明 | filter 的 predicate.test(纯判定) |
3 |
| 副作用 | peek 的 action.accept(调试专用出口) |
3 |
| 闭包纯净(effectively final) | lambda 捕获规则的编译错误 | 3 |
| 纯度 → 可并行 | 并行 forEach 丢数据 9748/10000 vs collect 10000 | 3 |
| 组合 | andThen/compose/Predicate.and/Consumer.andThen |
4 |
| 组合律 | map(f).map(g) ≡ map(f.andThen(g)) |
4 |
| 不可变 | Optional.map 不改自己、toUnmodifiableList |
5 |
| 可变内核折中 | Collectors.toList 的 List::add(受控可变) |
5 |
| 惰性 / 描述即值 | new StatelessOp(...) 不执行、evaluate 才点火 |
6 |
| fold / reduce | ReduceOps 的 state = reducer.apply(state, t) |
7 |
| 结合律 | combiner 可并行的条件 |
7 |
| flatMap / bind | mapper.apply(u) 换出小流灌下游、Optional 防嵌套 |
8 |
| monad 直觉 | Stream/Optional 的 map+flatMap 操作对 | 8 |
| 函数式核心+命令式外壳 | Sink 链纯变换、收货台/peek 攒副作用 | 9 |
术语对照
| 英文 | 中文 | 章节 |
|---|---|---|
| Functional Programming (FP) | 函数式编程 | 1 |
| First-class Function | 函数是一等公民 | 2 |
| SAM (Single Abstract Method) / Functional Interface | 单抽象方法接口 / 函数式接口 | 2 |
| Higher-order Function | 高阶函数 | 2、4 |
| Pure Function / Referential Transparency | 纯函数 / 引用透明 | 3 |
| Side Effect | 副作用 | 3 |
| Closure / Effectively Final | 闭包 / 最终有效 | 3 |
| Composition (andThen / compose) | 函数组合 | 4 |
| Immutability / Value Semantics | 不可变性 / 值语义 | 5 |
| Lazy Evaluation | 惰性求值 | 6 |
| Fold / Reduction | 折叠 / 归约 | 7 |
| flatMap / Bind (>>=) / Monad | 摊平映射 / 绑定 / 单子 | 8 |
| Curry / Pattern Matching / TCO | 柯里化 / 模式匹配 / 尾调用优化 | 9 |
记忆口诀
"函数当值随处走,纯不纯看副作用;compose 先、andThen 后,组合律里两路同;菜谱不跑等点火,fold 折叠替循环功;flatMap 拆包摊平走,核心纯、外壳糙,函数式够用乐悠悠。"
一句话总结
函数式编程 = 用变换造值 的三板斧(一等公民、纯函数、不可变性)加两个红利(可组合、可并行):Stream 源码里,mapper.apply(u) 是一等公民、peek 是副作用的受控出口、andThen 是高阶函数的活标本、Optional.map 是不可变的范本、evaluate 是惰性的点火器、flatMap 是"拆包→计算→摊平"的通用模式。Java 的正确姿势不是消灭命令式,而是把纯函数放在核心、把副作用压到外壳------菜谱保持纯净,厨房围着菜谱转。
动手实验清单(三个实验,各 10 分钟)
实验一:组合顺序与组合律 (对应第 4 章) 写 plus1 = x->x+1、times2 = x->x*2,打印 plus1.andThen(times2).apply(3) 与 plus1.compose(times2).apply(3)(应为 8 和 7);再验证 stream.map(plus1).map(times2) 与 stream.map(plus1.andThen(times2)) 输出一致;最后把两个 map 合并前后用 peek 打印元素观察执行顺序。
实验二:副作用的并行代价 (对应第 3 章) 把 D6 的实验放大到 10 万元素:parallel().forEach(unsafe::add) 对比 collect(toList()) 的元素数;然后把 unsafe 换成 Collections.synchronizedList(new ArrayList<>()) 观察"加锁修复"与 collect 的性能差异------体会"受控副作用"的代价曲线。
实验三:lambda 编译成了什么 (对应第 2 章) 写一个类,同时放两种写法:Function<String,Integer> f1 = x -> x.length();(lambda 表达式)与 Function<String,Integer> f2 = String::length;(方法引用)。javac 后:
javap -p YourClass:找合成的私有静态方法lambda$main$0(java.lang.String)------实测只有 lambda 表达式产生它(方法引用不产生,直接指向目标方法);javap -p -c YourClass:找invokedynamic指令 (两种写法都有,注释形如InvokeDynamic #0:apply)------这是 lambda 的真实实现机制:编译期只留下"配方",运行时才动态生成函数对象。
看懂这两样,"lambda 是语法糖"就有了字节码级的证据(实测 JDK 21 输出与上述一致)。