Java 函数式编程精讲:从 Stream 源码说起 —— 用真实源码学懂函数式思维

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 一个直觉,够用即可。


目录

  1. 怎么读这篇
  2. 函数式编程是什么
  3. 函数是一等公民
  4. 纯函数与副作用
  5. 组合与高阶函数
  6. 不可变性
  7. 惰性求值
  8. [reduce 与 fold](#reduce 与 fold "#7-reduce-%E4%B8%8E-fold")
  9. [flatMap 与链式上下文](#flatMap 与链式上下文 "#8-flatmap-%E4%B8%8E%E9%93%BE%E5%BC%8F%E4%B8%8A%E4%B8%8B%E6%96%87")
  10. [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")
  11. 总结速查表

0. 怎么读这篇

你将带走四样东西:

  1. 函数式编程的完整心智模型:一等公民、纯函数、副作用、不可变、组合、惰性、fold------每个概念都能落到 Stream 源码的具体行上;
  2. 一眼看懂 Function<? super T, ? extends R>、Function<T, R>.andThen(...) 这类签名背后的函数式语义(与《泛型精讲》互为表里);
  3. 判断"我的代码够不够函数式"的实践标准,以及 Java 的合理边界(不必为了纯而纯);
  4. 三个动手实验,把抽象概念跑成可见的输出。

前置知识:

需要 不需要
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)就是后一种世界观下的系统方法论,它有三板斧:

  1. 函数是一等公民------函数可以当参数、当返回值、当变量(第 2 章);
  2. 纯函数------同样的输入必得同样的输出,且不修改外界(第 3 章);
  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)**的定义就两条:

  1. 引用透明:同样的输入,永远得到同样的输出(不看表、不掷骰子、不读全局变量);
  2. 无副作用:不修改任何外部状态(不改参数对象、不写文件、不发请求)。

菜谱类比:标准菜谱是纯的------同样食材必出同样菜,且做菜过程不改变厨房的其他东西;如果菜谱里写"顺便把厨房灯关了",它就混入了副作用,做菜和改厨房状态纠缠在一起。

副作用(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 家族的三个证据:

  1. Stream 不改源数据 (《从入门到深入》3.②):list.stream().map(x -> x*10) 跑完,list 还是原样;
  2. Optional 的变换返回新盒子(源码见下);
  3. 不可变收集的显式 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/...)才驱动求值。惰性的三个工程红利:

  1. 短路 :findFirst 只看够用的元素(anyMatch 找到即停)------"按需计算",不浪费;
  2. 融合 :一次遍历穿全链,无中间集合(copyInto 的 forEachRemaining);
  3. 优化空间 :账本(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 惰性的代价(诚实面)

⚠️ 惰性不全是优点,两个真实的坑(系列前作都踩过):

  1. 副作用时序不可读 :peek 里的打印/修改在求值时才发生,代码顺序 ≠ 执行顺序(peek(...).count() 可能一次都不跑------《实现原理》5.1 实测);
  2. 错误推迟暴露: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 / >>=)。看两个事实就够了:

  1. Stream 和 Optional 都实现了同构的操作对:map(换值不换包装)+ flatMap(换值且摊平包装);
  2. 有了这两个操作,"带包装的值"(可能为空、可能多个)就能在包装内连续计算 而不用层层解包------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 实践清单:五条可执行的建议

  1. lambda 保持纯:不改捕获变量(编译器已拦)、不改参数对象、不在 map/filter 里调 RPC/写库------业务规则进 lambda,副作用挪到 collect/forEach 的边界;
  2. peek 只看不改 :调试观察可以,peek(s -> s.setXxx(...)) 禁止(《从入门到深入》13 章坑 3 的源码级原因见 3.1);
  3. collect 优于 forEach+add:并行安全由框架合并保证(3.3 实测的 9748 教训);
  4. 可变性显式化 :要不可变用 toUnmodifiableList()/List.of(),要可变用 toCollection(ArrayList::new)------别让"可变"成为意外;
  5. 组合优于巨型 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 输出与上述一致)。

相关推荐
字节跳动数据库28 分钟前
火山引擎缓存数据库:如何构建超大规模缓存集群的无感弹性能力
数据库·人工智能·后端
IT枫斗者枫哥29 分钟前
Java 异步导出只测最终行数,为什么下载时仍会少一行?
java·后端
用户78506119579730 分钟前
不会前端,我靠 AI 和 Python 做了一个 4K 壁纸站
后端
噜噜学上位机31 分钟前
什么是多态?
后端
站大爷IP35 分钟前
Python的类方法把我坑惨了,原来@classmethod和@staticmethod的区别这么大
后端
Gopher_HBo40 分钟前
StartCPUProfile 秒返回,是谁把 cpu.pprof 写满的?
后端
WangYu41 分钟前
后端进阶路线:从写 CRUD 到定架构,这一张图讲透
后端
用户3681336681631 小时前
外部资源目录设计:把导航卡片与查询结果分开
后端