Java 函数式编程深度指南

函数式编程（Functional Programming, FP）作为一种起源于 λ 演算的编程范式，自 LISP（1958）诞生以来深刻影响了计算机科学的发展。Java 在 2014 年发布的 Java 8 中正式引入 Lambda 表达式、Stream API 与 java.util.function 包，标志着这门以面向对象为核心的语言完成了”对象 + 函数”的双范式融合。本文将从 λ 演算的形式化基础出发，深入剖析 Java 函数式接口的字节码本质、Stream 的惰性求值机制、并行流的 Fork/Join 调度原理，并通过完整的工程案例展示函数式思维如何重构传统命令式代码。读者将不仅学会”如何使用 Lambda”，更能理解”为何 invokedynamic 是 Java 函数式实现的基石”，从而在架构设计与性能优化层面做出有依据的决策。

1. 学习目标（基于 Bloom 分类法）

本节以 Bloom 教育目标分类法（Anderson 2001 修订版）为框架，对学习目标进行显式分级。

1.1 认知层级目标

1.2 学习成果自检清单

完成本章学习后，读者应能独立完成以下任务：

1. 在不查阅文档的前提下，画出 java.util.function 包中核心函数式接口的继承关系图。
2. 用一句话向同事解释 invokedynamic 与 Lambda 表达式的关系，并说明为何 Java 不采用匿名内部类方案。
3. 在白板上推导一段 Stream 流水线的执行过程，标注每个操作的惰性求值时机。
4. 设计一个基于 Collector 的自定义收集器，将订单流聚合为按月份分组的统计报告。
5. 对比 parallelStream、CompletableFuture、虚拟线程三种并发模型的优缺点，给出选型建议。
6. 重写一段 50 行的命令式循环代码为函数式风格，并保证功能等价、性能不退化。

1.3 前置知识地图

Java 基础
    │
    ├── 面向对象（封装、继承、多态）
    ├── 集合框架（List、Map、Set）
    ├── 泛型（类型参数、通配符、类型擦除）
    └── 异常处理（try-catch-finally）
            │
            ▼
Java 函数式编程（本章）
    │
    ├── 语法层：Lambda 表达式、方法引用、构造引用
    ├── API 层：函数式接口、Stream、Optional、Collectors
    ├── 语义层：纯函数、不可变性、惰性求值、高阶函数
    └── 字节码层：invokedynamic、LambdaMetafactory、LambdaForm
            │
            ▼
进阶应用
    │
    ├── 响应式编程（Reactor、RxJava）
    ├── 并行计算（ForkJoinPool、parallelStream）
    └── DSL 设计（Builder 模式 + 函数组合）

1.4 章节阅读建议

• 零基础读者：建议按顺序阅读第 2-5 节，配合第 5 节代码示例上机实操，再回到第 3、4 节深化理论。
• 有 Java 8 经验的工程师：可跳过第 2 节基础部分，直接阅读第 3 节形式化定义、第 4 节字节码机制、第 7 节反模式。
• 架构师：重点关注第 6 节对比分析、第 8 节工程实践与第 9 节案例研究，特别是函数式思维如何重塑领域建模。

2. 历史动机与演化

2.1 函数式编程的数学渊源

函数式编程的根基可追溯至 Alonzo Church 于 1936 年提出的 λ 演算（Lambda Calculus）。λ 演算是一个形式系统，用于研究函数定义、函数应用和递归。其核心语法仅有三条规则：

表达式 ::= 变量 | λ.变量.表达式 | 表达式 表达式

例如，恒等函数写作 λx.x，应用于参数写作 (λx.x) y，通过 β-归约（β-reduction）得到 y。Church 证明 λ 演算与图灵机等价，奠定了可计算性理论的基础。

λ 演算的三个核心特性直接映射到现代函数式编程：

1. 函数是一等公民（First-class citizen）：函数可以作为参数传递、作为返回值、赋值给变量。
2. 纯函数（Pure function）：相同输入始终产生相同输出，无副作用。
3. 高阶函数（Higher-order function）：接受函数作为参数或返回函数的函数。

1958 年，John McCarthy 基于 λ 演算设计了 LISP，开启了函数式编程的工程化实践。此后 ML（1973）、Haskell（1990）、Erlang（1986）等语言进一步发展了类型系统、惰性求值、模式匹配等特性。

2.2 Java 引入函数式编程的动机

Java 8 之前，函数式编程在 Java 中只能通过匿名内部类”模拟”，但语法冗长、性能开销大。考虑以下排序示例：

// Java 7 匿名内部类写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
});

// Java 8 Lambda 写法
names.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));

// Java 8 方法引用写法
names.sort(Comparator.comparingInt(String::length));

从 6 行代码压缩到 1 行，不仅是语法糖，更是抽象层次的提升。Java 设计者引入函数式编程的核心动机包括：

1. 并行化需求：多核 CPU 普及后，命令式的可变状态循环难以并行化，而 Stream 的无状态操作天然适合并行。
2. 代码表达力：声明式风格让代码更接近业务意图，减少样板代码。
3. API 设计灵活性：函数式接口允许 API 接受行为参数，如 forEach、map、filter。
4. 生态竞争：Scala、Groovy 等 JVM 语言已支持函数式特性，Java 需保持竞争力。

2.3 Java 函数式编程的版本演进

2.4 设计哲学：为何 Java 不采用”纯”函数式

Java 选择”对象 + 函数”的混合范式，而非 Haskell 式的纯函数式，原因如下：

1. 向后兼容：Java 拥有海量遗留代码，激进范式转变会破坏生态。
2. 可变状态的现实需求：I/O、UI、数据库操作本质上是带副作用的，纯函数式需通过 Monad 等抽象处理，对工程师要求高。
3. 性能考量：纯函数式语言的不可变数据结构在密集计算场景下可能产生大量临时对象，Java 选择让开发者自行权衡。
4. 渐进式采纳：开发者可在需要时使用函数式风格，无需全盘接受。

这种”务实主义”使 Java 函数式编程既保留了 OOP 的封装与多态，又获得了 FP 的表达力与并行能力。

3. 形式化定义

3.1 函数式接口的形式化定义

定义 3.1（函数式接口）：一个接口 $I$ 是函数式接口，当且仅当 $I$ 恰好声明了一个抽象方法 $m$。形式化地：

其中，来自 Object 类的公开方法（如 equals、toString）不计入抽象方法数。

注：@FunctionalInterface 注解是可选的，仅用于编译期检查。即使不标注，满足上述条件的接口仍可作为函数式接口使用（如 Comparator）。

3.2 Lambda 表达式的类型推断

Lambda 表达式的类型由目标类型（Target Type）推断。设目标类型为 $T = I_\alpha$（函数式接口），其函数描述符（Functional Descriptor）为 $\tau_1 \to \tau_2$。Lambda 表达式 $(x) \to e$ 的类型检查规则为：

例如，Comparator<String> 的描述符为 (String, String) -> int，因此 (s1, s2) -> s1.length() - s2.length() 的类型可推断为 Comparator<String>。

3.3 Stream 流水线的代数结构

Stream 流水线可形式化为一个单子（Monad）。定义 Stream<T> 为类型构造子，其满足以下单子定律：

1. 左单位律（Left identity）：Stream.of(x).flatMap(f) ≡ f.apply(x)
2. 右单位律（Right identity）：s.flatMap(Stream::of) ≡ s
3. 结合律（Associativity）：s.flatMap(f).flatMap(g) ≡ s.flatMap(x -> f.apply(x).flatMap(g))

flatMap 即单子的 bind 操作（写作 >>=），of 即 return/pure。这保证了 Stream 流水线的组合正确性。

3.4 纯函数的数学性质

定义 3.2（纯函数）：函数 $f : A \to B$ 是纯函数，当且仅当：

1. 确定性：$\forall x \in A, \forall i, j, f_i(x) = f_j(x)$（多次调用结果相同）
2. 无副作用：$f$ 的执行不修改任何外部状态

纯函数满足引用透明性（Referential Transparency）：表达式 $e$ 与其求值结果 $v$ 可互换而不影响程序语义。形式化地：

这是函数式编程可推理性、可测试性、可并行化的数学基础。

3.5 柯里化的形式化

定义 3.3（柯里化）：将 $n$ 元函数 $f : A_1 \times A_2 \times \cdots \times A_n \to B$ 转换为一元函数链的过程：

Java 中的柯里化通过返回 Function 链实现：

// 二元函数
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;

// 柯里化后
Function<Integer, Function<Integer, Integer>> curriedAdd = a -> b -> a + b;

// 部分应用
Function<Integer, Integer> add5 = curriedAdd.apply(5);
System.out.println(add5.apply(3)); // 8

柯里化使部分应用（Partial Application）成为可能，是函数组合的核心技术。

4. 理论推导：函数式编程的内部机制

4.1 invokedynamic 与 Lambda 的字节码实现

Java 8 的 Lambda 表达式并不编译为匿名内部类，而是通过 invokedynamic（JSR 292）实现。这一设计决策由 Brian Goetz 主导，核心动机是：

1. 避免运行时类生成开销：匿名内部类会在编译期生成 .class 文件，增加类加载开销。
2. 保持实现灵活性：将 Lambda 的实际实现策略延迟到运行时，由 LambdaMetafactory 决定。
3. 性能优化空间：未来可采用方法句柄（MethodHandle）的内联优化。

考虑以下 Lambda：

Comparator<String> cmp = (s1, s2) -> Integer.compare(s1.length(), s2.length());

编译后的字节码大致为：

INVOKEDYNAMIC compare()Ljava/util/Comparator; [
  // bootstrap method
  LambdaMetafactory.metafactory(...),
  // method handle to synthetic lambda method
  lambda$0(Ljava/lang/String;Ljava/lang/String;)I
]

其中 lambda$0 是编译器生成的合成方法（Synthetic Method），包含 Lambda 体的实际逻辑。LambdaMetafactory.metafactory 在首次调用时生成一个实现 Comparator 的动态类，将 lambda$0 包装为具体实现。

首次调用 vs 后续调用：

• 首次调用：metafactory 解析调用点（CallSite），生成 LambdaForm，绑定方法句柄。
• 后续调用：直接调用已绑定的方法句柄，性能接近直接方法调用。

通过 -Djdk.internal.lambda.dumpProxyClasses=/tmp/lambda 可导出生成的动态类，验证其结构。

4.2 Stream 流水线的惰性求值机制

Stream 的核心设计是惰性求值（Lazy Evaluation）：中间操作（Intermediate Operation）不会立即执行，只有在终端操作（Terminal Operation）触发时才回溯执行整个流水线。

惰性求值的实现原理：

1. 每个中间操作返回一个新的 Stream 实例（如 ReferencePipeline），保存上游 Stage 引用与操作逻辑。
2. 终端操作触发 evaluate 方法，从 Sink 链的尾端向头端反向回溯。
3. 每个元素从源头流向 Sink 链，依次被 filter、map 等处理。

考虑以下代码：

List<String> result = Stream.of("a", "bb", "ccc", "dddd")
    .filter(s -> s.length() > 1)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

执行时 Sink 链的结构：

Source -> filterSink -> mapSink -> collectSink
            ↑           ↑           ↑
        接收元素       接收过滤后的   收集到结果
        判断长度>1     转大写

惰性求值的关键优势：

1. 短路优化：findFirst、anyMatch 等操作可提前终止。
2. 融合优化：多个操作可融合为单次遍历，避免中间集合。
3. 无限流支持：Stream.iterate、Stream.generate 可表示无限序列。

短路示例：

// 只处理到第一个匹配元素即停止
Optional<String> first = Stream.of("a", "bb", "ccc", "dddd")
    .peek(s -> System.out.println("处理: " + s))  // 调试用
    .filter(s -> s.length() > 2)
    .findFirst();

// 输出：
// 处理: a
// 处理: bb
// 处理: ccc
// 结果: Optional[CCC]

可以看到 dddd 未被处理，体现了短路优化。

4.3 并行流的 Fork/Join 调度

parallelStream 与 stream().parallel() 基于 ForkJoinPool.commonPool() 实现并行。其工作流程：

1. 分割（Fork）：将源数据递归分割为子任务，直到达到阈值（默认每个任务约 1024 个元素）。
2. 执行（Compute）：每个子任务在工作线程中独立执行流水线。
3. 合并（Join）：将子任务结果合并为最终结果。

Spliterator 的分割语义：

// ArrayList 的 Spliterator 支持 ORDERED | SIZED | SUBSIZED
// 可精确分割
Spliterator<String> spliterator = list.spliterator();
Spliterator<String> prefix = spliterator.trySplit();  // 分割前半部分

并行流的适用条件：

1. 数据源支持高效分割（ArrayList 优于 LinkedList）。
2. 操作无状态（不依赖外部可变变量）。
3. 操作无副作用（不修改共享状态）。
4. 数据量足够大（通常 > 10000 元素）。
5. 操作本身计算量足够大（简单 map 难以抵消并行开销）。

4.4 函数式接口的字节码与运行时

@FunctionalInterface 注解在运行时通过 @Retention(RetentionPolicy.RUNTIME) 保留，但 JVM 不依赖它判断函数式接口。实际判断逻辑在 LambdaMetafactory 中：

// 简化的 LambdaMetafactory.metafactory 逻辑
public static CallSite metafactory(...) {
    // 1. 校验目标接口是否为函数式接口
    if (!isFunctionalInterface(targetType)) {
        throw new LambdaConversionException("Not a functional interface");
    }
    // 2. 提取函数描述符
    MethodType descriptor = targetType.getFunctionalDescriptor();
    // 3. 校验方法句柄类型与描述符兼容
    if (!isAdaptCompatible(actualMethodType, descriptor)) {
        throw new LambdaConversionException("Type mismatch");
    }
    // 4. 生成动态代理类
    Class<?> implClass = generateLambdaClass(...);
    // 5. 绑定调用点
    return new ConstantCallSite(MethodHandles.constant(implClass, implClass.newInstance()));
}

这一机制使得 Lambda 的实现策略可在未来演进（如 GraalVM 的部分求值优化），而无需修改字节码。

4.5 方法引用的四种形式

方法引用（Method Reference）是 Lambda 的语法糖，编译器将其转换为方法句柄。四种形式：

任意对象实例方法引用的语义：第一个参数成为接收者（receiver），其余参数作为方法参数。例如 String::concat 等价于 (s1, s2) -> s1.concat(s2)。

4.6 Collectors 的归约代数

Collector 接口定义了五个组件：

public interface Collector<T, A, R> {
    Supplier<A> supplier();           // 创建累加器初始值
    BiConsumer<A, T> accumulator();   // 累加元素到累加器
    BinaryOperator<A> combiner();     // 合并两个累加器（并行用）
    Function<A, R> finisher();        // 最终转换
    Set<Characteristics> characteristics();  // 特征标识
}

其归约过程形式化为：

其中 reduce 在并行场景下分治执行：

1. 将流分为 $n$ 个子流。
2. 每个子流独立执行 supplier → accumulator。
3. 通过 combiner 两两合并子结果。
4. finisher 转换为最终结果。

Characteristics.IDENTITY_FINISH 表示 finisher 是恒等函数，可省略。UNORDERED 表示结果与顺序无关，允许并行合并无序化。CONCURRENT 表示累加器线程安全，可并行累加同一容器（罕见）。

5. 代码示例：从入门到进阶的完整实战

5.1 入门：Lambda 基础语法

package com.example.fp.basics;

import java.util.*;
import java.util.function.*;

public class LambdaBasics {

    public static void main(String[] args) {
        // 无参数 Lambda（Runnable 的描述符为 () -> void）
        Runnable r = () -> System.out.println("Hello, Lambda");
        r.run();

        // 单参数 Lambda（Consumer<String> 的描述符为 (String) -> void）
        Consumer<String> print = s -> System.out.println(s);
        print.accept("Hello, Consumer");

        // 类型推断省略
        Consumer<String> printInferred = s -> System.out.println(s);

        // 多参数 Lambda（BiFunction 的描述符为 (Integer, Integer) -> Integer）
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(3, 5));  // 8

        // 代码块 Lambda（需要 return 语句）
        Comparator<String> cmp = (s1, s2) -> {
            int diff = s1.length() - s2.length();
            return diff != 0 ? diff : s1.compareTo(s2);
        };

        // 方法引用：四种形式
        Consumer<String> println = System.out::println;  // 特定对象实例方法引用
        Function<String, Integer> len = String::length;  // 任意对象实例方法引用
        Function<String, Integer> parse = Integer::parseInt;  // 静态方法引用
        Supplier<ArrayList<String>> factory = ArrayList::new;  // 构造方法引用

        // 变量捕获（effectively final 才能捕获）
        String prefix = "User: ";
        Consumer<String> greet = name -> System.out.println(prefix + name);
        greet.accept("Alice");
        // prefix = "Admin: ";  // 编译错误：被捕获变量必须 effectively final
    }
}

5.2 进阶：自定义函数式接口与组合

package com.example.fp.advanced;

import java.util.function.*;

/**
 * 自定义函数式接口，支持链式组合
 */
@FunctionalInterface
public interface Transformer<T, R> {
    R transform(T input);

    /**
     * 与后续 Function 组合，等价于 Function.andThen
     */
    default <V> Transformer<T, V> andThen(Function<R, V> after) {
        return input -> after.apply(this.transform(input));
    }

    /**
     * 与前置 Function 组合，等价于 Function.compose
     */
    default <V> Transformer<V, R> compose(Function<V, T> before) {
        return input -> this.transform(before.apply(input));
    }
}

class TransformerDemo {
    public static void main(String[] args) {
        Transformer<String, Integer> strLen = String::length;
        Transformer<String, String> upper = String::toUpperCase;

        // 组合：先转大写，再求长度，再格式化
        Transformer<String, String> pipeline = upper
            .andThen(len -> "长度=" + len)
            .andThen(s -> "[" + s + "]");

        System.out.println(pipeline.transform("hello"));  // [长度=5]
    }
}

5.3 实战：Stream 数据处理管道

package com.example.fp.stream;

import java.util.*;
import java.util.stream.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;

public class StreamPipeline {

    record Order(Long id, String customer, BigDecimal amount,
                 String status, LocalDateTime createdAt) {}

    public static void main(String[] args) {
        List<Order> orders = List.of(
            new Order(1L, "Alice", new BigDecimal("100.50"), "COMPLETED",
                LocalDateTime.of(2024, 1, 15, 10, 0)),
            new Order(2L, "Bob", new BigDecimal("250.00"), "COMPLETED",
                LocalDateTime.of(2024, 1, 20, 14, 30)),
            new Order(3L, "Alice", new BigDecimal("75.25"), "PENDING",
                LocalDateTime.of(2024, 2, 1, 9, 15)),
            new Order(4L, "Charlie", new BigDecimal("500.00"), "COMPLETED",
                LocalDateTime.of(2024, 2, 5, 16, 45)),
            new Order(5L, "Bob", new BigDecimal("180.75"), "CANCELLED",
                LocalDateTime.of(2024, 2, 10, 11, 20))
        );

        // 1. 基本过滤与映射
        List<String> completedCustomers = orders.stream()
            .filter(o -> "COMPLETED".equals(o.status()))
            .map(Order::customer)
            .distinct()
            .sorted()
            .collect(Collectors.toList());
        System.out.println("已完成订单客户: " + completedCustomers);

        // 2. 分组统计
        Map<String, Long> countByCustomer = orders.stream()
            .collect(Collectors.groupingBy(Order::customer, Collectors.counting()));
        System.out.println("客户订单数: " + countByCustomer);

        // 3. 分组求和
        Map<String, BigDecimal> sumByCustomer = orders.stream()
            .filter(o -> "COMPLETED".equals(o.status()))
            .collect(Collectors.groupingBy(
                Order::customer,
                Collectors.reducing(
                    BigDecimal.ZERO,
                    Order::amount,
                    BigDecimal::add
                )
            ));
        System.out.println("客户已完成总额: " + sumByCustomer);

        // 4. 分组后取最大值
        Map<String, Optional<Order>> maxByCustomer = orders.stream()
            .collect(Collectors.groupingBy(
                Order::customer,
                Collectors.maxBy(Comparator.comparing(Order::amount))
            ));
        maxByCustomer.forEach((k, v) ->
            System.out.println(k + " 最大订单: " + v.map(Order::amount).orElse(null)));

        // 5. 多级分组：客户 + 状态
        Map<String, Map<String, List<Order>>> multiGrouped = orders.stream()
            .collect(Collectors.groupingBy(
                Order::customer,
                Collectors.groupingBy(Order::status)
            ));
        System.out.println("多级分组: " + multiGrouped);

        // 6. 分区
        Map<Boolean, List<Order>> partitioned = orders.stream()
            .collect(Collectors.partitioningBy(o ->
                o.amount().compareTo(new BigDecimal("200")) > 0));
        System.out.println("大额订单数: " + partitioned.get(true).size());

        // 7. 统计摘要
        DoubleSummaryStatistics stats = orders.stream()
            .filter(o -> "COMPLETED".equals(o.status()))
            .mapToDouble(o -> o.amount().doubleValue())
            .summaryStatistics();
        System.out.printf("已完成订单统计: count=%d, sum=%.2f, avg=%.2f, max=%.2f%n",
            stats.getCount(), stats.getSum(), stats.getAverage(), stats.getMax());

        // 8. 字符串拼接
        String customerList = orders.stream()
            .map(Order::customer)
            .distinct()
            .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("客户列表: " + customerList);

        // 9. 不可变收集
        List<String> immutable = orders.stream()
            .map(Order::customer)
            .distinct()
            .collect(Collectors.toUnmodifiableList());

        // 10. Java 16+ 简化收集
        List<Order> completedOrders = orders.stream()
            .filter(o -> "COMPLETED".equals(o.status()))
            .toList();  // 返回不可变 List
    }
}

5.4 实战：自定义 Collector

package com.example.fp.collector;

import java.util.*;
import java.util.function.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;

/**
 * 自定义收集器：将流元素收集为以指定分隔符连接、带前后缀的字符串
 */
public class JoiningCollector
        implements Collector<String, StringJoiner, String> {

    private final String delimiter;
    private final String prefix;
    private final String suffix;

    public JoiningCollector(String delimiter, String prefix, String suffix) {
        this.delimiter = delimiter;
        this.prefix = prefix;
        this.suffix = suffix;
    }

    @Override
    public Supplier<StringJoiner> supplier() {
        return () -> new StringJoiner(delimiter, prefix, suffix);
    }

    @Override
    public BiConsumer<StringJoiner, String> accumulator() {
        return StringJoiner::add;
    }

    @Override
    public BinaryOperator<StringJoiner> combiner() {
        return StringJoiner::merge;
    }

    @Override
    public Function<StringJoiner, String> finisher() {
        return StringJoiner::toString;
    }

    @Override
    public Set<Characteristics> characteristics() {
        // 不标记 IDENTITY_FINISH，因为 StringJoiner -> String 是有损转换
        return Set.of(Characteristics.CONCURRENT);
    }

    public static void main(String[] args) {
        String result = List.of("Alice", "Bob", "Charlie").stream()
            .collect(new JoiningCollector(", ", "{", "}"));
        System.out.println(result);  // {Alice, Bob, Charlie}
    }
}

/**
 * 自定义收集器：分位数计算
 */
class PercentileCollector implements Collector<Double, List<Double>, Map<String, Double>> {

    @Override
    public Supplier<List<Double>> supplier() {
        return ArrayList::new;
    }

    @Override
    public BiConsumer<List<Double>, Double> accumulator() {
        return List::add;
    }

    @Override
    public BinaryOperator<List<Double>> combiner() {
        return (l1, l2) -> {
            l1.addAll(l2);
            return l1;
        };
    }

    @Override
    public Function<List<Double>, Map<String, Double>> finisher() {
        return list -> {
            list.sort(Double::compare);
            int n = list.size();
            Map<String, Double> result = new LinkedHashMap<>();
            result.put("p50", percentile(list, 0.5));
            result.put("p90", percentile(list, 0.9));
            result.put("p99", percentile(list, 0.99));
            return result;
        };
    }

    private double percentile(List<Double> sorted, double p) {
        int index = (int) Math.ceil(p * sorted.size()) - 1;
        return sorted.get(Math.max(0, index));
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Set.of();  // 有 finisher，不标记 IDENTITY_FINISH
    }

    public static void main(String[] args) {
        List<Double> data = java.util.stream.DoubleStream
            .generate(() -> Math.random() * 100)
            .limit(1000)
            .boxed()
            .collect(Collectors.toList());

        Map<String, Double> percentiles = data.stream()
            .collect(new PercentileCollector());
        System.out.println("分位数: " + percentiles);
    }
}

5.5 实战：并行流与自定义 ForkJoinPool

package com.example.fp.parallel;

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

public class ParallelStreamDemo {

    public static void main(String[] args) throws Exception {
        // 大数据集
        List<Integer> bigData = IntStream.rangeClosed(1, 10_000_000)
            .boxed()
            .collect(Collectors.toList());

        // 1. 串行流
        long start = System.currentTimeMillis();
        long sumSequential = bigData.stream()
            .mapToLong(x -> (long) x * x)
            .sum();
        System.out.println("串行耗时: " + (System.currentTimeMillis() - start) + "ms");

        // 2. 并行流（使用默认 commonPool）
        start = System.currentTimeMillis();
        long sumParallel = bigData.parallelStream()
            .mapToLong(x -> (long) x * x)
            .sum();
        System.out.println("并行耗时: " + (System.currentTimeMillis() - start) + "ms");

        // 3. 自定义并行度的 ForkJoinPool
        ForkJoinPool customPool = new ForkJoinPool(4);
        try {
            start = System.currentTimeMillis();
            long sumCustom = customPool.submit(() ->
                bigData.parallelStream()
                    .mapToLong(x -> (long) x * x)
                    .sum()
            ).get();
            System.out.println("自定义池并行耗时: " + (System.currentTimeMillis() - start) + "ms");
        } finally {
            customPool.shutdown();
        }

        // 4. 并行流的危险：共享可变状态
        List<Integer> unsafeList = new ArrayList<>();
        IntStream.rangeClosed(1, 1000).parallel()
            .forEach(unsafeList::add);  // 危险！ArrayList 非线程安全
        System.out.println("不安全列表大小（可能丢失）: " + unsafeList.size());

        // 5. 安全的并行收集
        List<Integer> safeList = IntStream.rangeClosed(1, 1000).parallel()
            .boxed()
            .collect(Collectors.toList());
        System.out.println("安全列表大小: " + safeList.size());

        // 6. 并行排序（注意顺序）
        List<Integer> sorted = bigData.parallelStream()
            .sorted(Comparator.reverseOrder())
            .collect(Collectors.toList());
        System.out.println("降序前10: " + sorted.subList(0, 10));
    }
}

5.6 实战：函数组合与柯里化

package com.example.fp.composition;

import java.util.*;
import java.util.function.*;

public class FunctionComposition {

    public static void main(String[] args) {
        // 基本函数组合
        Function<Integer, Integer> doubleIt = x -> x * 2;
        Function<Integer, Integer> addOne = x -> x + 1;
        Function<Integer, Integer> square = x -> x * x;

        // compose: g.compose(f).apply(x) = g(f(x))
        Function<Integer, Integer> doubleThenAdd = addOne.compose(doubleIt);
        System.out.println(doubleThenAdd.apply(5));  // (5*2)+1 = 11

        // andThen: f.andThen(g).apply(x) = g(f(x))
        Function<Integer, Integer> addThenDouble = doubleIt.andThen(addOne);
        System.out.println(addThenDouble.apply(5));  // (5+1)*2 = 12

        // 多函数组合
        Function<Integer, Integer> pipeline = doubleIt
            .andThen(addOne)
            .andThen(square);
        System.out.println(pipeline.apply(5));  // ((5*2)+1)^2 = 121

        // 柯里化：将 BiFunction 转为 Function 链
        BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
        Function<Integer, Function<Integer, Integer>> curriedMultiply =
            a -> b -> a * b;

        // 部分应用
        Function<Integer, Integer> triple = curriedMultiply.apply(3);
        Function<Integer, Integer> quadruple = curriedMultiply.apply(4);
        System.out.println(triple.apply(5));     // 15
        System.out.println(quadruple.apply(5));  // 20

        // 高阶函数：函数作为参数
        Function<Integer, Integer> composed = composeAll(
            Arrays.asList(doubleIt, addOne, square)
        );
        System.out.println(composed.apply(5));  // ((5*2)+1)^2 = 121

        // Predicate 组合
        Predicate<Integer> isPositive = x -> x > 0;
        Predicate<Integer> isEven = x -> x % 2 == 0;
        Predicate<Integer> isPositiveEven = isPositive.and(isEven);
        Predicate<Integer> isPositiveOrEven = isPositive.or(isEven);
        Predicate<Integer> isNegative = isPositive.negate();

        System.out.println(isPositiveEven.test(4));   // true
        System.out.println(isPositiveEven.test(3));   // false
        System.out.println(isNegative.test(-5));      // true

        // Consumer 组合
        Consumer<String> printUpper = s -> System.out.println(s.toUpperCase());
        Consumer<String> printLength = s -> System.out.println(s.length());
        Consumer<String> combined = printUpper.andThen(printLength);
        combined.accept("Hello");  // HELLO \n 5
    }

    /**
     * 将多个 Function 组合为一个
     */
    @SafeVarargs
    public static <T> Function<T, T> composeAll(Function<T, T>... functions) {
        return Arrays.stream(functions)
            .reduce(Function.identity(), Function::andThen);
    }

    /**
     * 重载：从 List 组合
     */
    public static <T> Function<T, T> composeAll(List<Function<T, T>> functions) {
        return functions.stream()
            .reduce(Function.identity(), Function::andThen);
    }
}

5.7 实战：Optional 的函数式用法

package com.example.fp.optional;

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class OptionalDemo {

    public static void main(String[] args) {
        // 创建 Optional
        Optional<String> present = Optional.of("Hello");
        Optional<String> empty = Optional.empty();
        Optional<String> nullable = Optional.ofNullable(null);

        // 函数式消费
        present.map(String::toUpperCase)
            .ifPresent(System.out::println);  // HELLO

        // 链式操作
        String result = present
            .filter(s -> s.length() > 3)
            .map(String::toUpperCase)
            .orElse("DEFAULT");
        System.out.println(result);  // HELLO

        // flatMap 处理嵌套 Optional
        Optional<Optional<String>> nested = present.map(s -> Optional.of(s + "!"));
        Optional<String> flattened = present.flatMap(s -> Optional.of(s + "!"));
        System.out.println(flattened.orElse(""));  // Hello!

        // Java 9+ ifPresentOrElse
        present.ifPresentOrElse(
            s -> System.out.println("存在: " + s),
            () -> System.out.println("不存在")
        );

        // Java 9+ or
        Optional<String> fallback = empty.or(() -> Optional.of("默认值"));
        System.out.println(fallback.get());  // 默认值

        // Java 9+ stream
        long count = Stream.of(
                Optional.of("a"),
                Optional.empty(),
                Optional.of("b")
            )
            .flatMap(Optional::stream)
            .count();
        System.out.println("非空数量: " + count);  // 2

        // 实战：避免 null 检查地狱
        User user = findUser(1L).orElseThrow(() -> new RuntimeException("用户不存在"));
        System.out.println(user.name());
    }

    record User(Long id, String name) {}

    static Optional<User> findUser(Long id) {
        if (id == 1L) {
            return Optional.of(new User(1L, "Alice"));
        }
        return Optional.empty();
    }
}

5.8 实战：原始类型流

package com.example.fp.primitive;

import java.util.*;
import java.util.stream.*;

public class PrimitiveStreamDemo {

    public static void main(String[] args) {
        // IntStream 避免装箱开销
        int[] numbers = IntStream.rangeClosed(1, 100).toArray();

        // 统计摘要
        IntSummaryStatistics stats = IntStream.of(numbers)
            .filter(n -> n % 2 == 0)
            .summaryStatistics();
        System.out.printf("偶数统计: count=%d, sum=%d, avg=%.2f, min=%d, max=%d%n",
            stats.getCount(), stats.getSum(), stats.getAverage(),
            stats.getMin(), stats.getMax());

        // 数值计算
        long factorial = LongStream.rangeClosed(1, 20)
            .reduce(1L, (a, b) -> a * b);
        System.out.println("20! = " + factorial);

        // 斐波那契数列（iterate）
        List<Long> fibonacci = Stream.iterate(
                new long[]{0, 1},
                pair -> new long[]{pair[1], pair[0] + pair[1]}
            )
            .limit(20)
            .map(pair -> pair[0])
            .collect(Collectors.toList());
        System.out.println("斐波那契前20项: " + fibonacci);

        // 勾股数
        record PythagoreanTriple(int a, int b, int c) {}
        List<PythagoreanTriple> triples = IntStream.rangeClosed(1, 100)
            .boxed()
            .flatMap(a -> IntStream.rangeClosed(a, 100)
                .filter(b -> Math.sqrt(a * a + b * b) % 1 == 0)
                .mapToObj(b -> new PythagoreanTriple(a, b,
                    (int) Math.sqrt(a * a + b * b))))
            .collect(Collectors.toList());
        System.out.println("勾股数（前5组）: " + triples.subList(0, 5));

        // DoubleStream 浮点计算
        double pi = DoubleStream.iterate(1.0, n -> n + 2)
            .limit(1000)
            .map(n -> 4 * Math.pow(-1, (n - 1) / 2) / n)
            .sum();
        System.out.printf("π ≈ %.6f%n", pi);
    }
}

5.9 实战：Stream 高级操作

package com.example.fp.advanced;

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class AdvancedStreamOps {

    public static void main(String[] args) {
        // 1. flatMap 展平嵌套结构
        List<List<Integer>> nested = List.of(
            List.of(1, 2, 3),
            List.of(4, 5),
            List.of(6, 7, 8, 9)
        );
        List<Integer> flattened = nested.stream()
            .flatMap(List::stream)
            .collect(Collectors.toList());
        System.out.println("展平: " + flattened);

        // 2. flatMap 处理字符串
        List<String> words = List.of("Hello World", "Java Stream", "Flat Map");
        List<String> chars = words.stream()
            .flatMap(s -> Arrays.stream(s.split(" ")))
            .collect(Collectors.toList());
        System.out.println("分词: " + chars);

        // 3. reduce 归约
        Optional<Integer> sum = Stream.of(1, 2, 3, 4, 5)
            .reduce(Integer::sum);
        System.out.println("求和: " + sum.orElse(0));

        // 4. 带初始值的 reduce
        int product = Stream.of(1, 2, 3, 4, 5)
            .reduce(1, (a, b) -> a * b);
        System.out.println("阶乘: " + product);

        // 5. 复杂对象归约
        record Acc(int sum, int count) {}
        Acc result = Stream.of(1, 2, 3, 4, 5)
            .reduce(
                new Acc(0, 0),
                (acc, n) -> new Acc(acc.sum() + n, acc.count() + 1),
                (a1, a2) -> new Acc(a1.sum() + a2.sum(), a1.count() + a2.count())
            );
        System.out.println("平均: " + (double) result.sum() / result.count());

        // 6. takeWhile / dropWhile (Java 9+)
        List<Integer> taken = Stream.of(1, 2, 3, 4, 5, 2, 1)
            .takeWhile(n -> n < 4)
            .collect(Collectors.toList());
        System.out.println("takeWhile: " + taken);  // [1, 2, 3]

        List<Integer> dropped = Stream.of(1, 2, 3, 4, 5, 2, 1)
            .dropWhile(n -> n < 4)
            .collect(Collectors.toList());
        System.out.println("dropWhile: " + dropped);  // [4, 5, 2, 1]

        // 7. ofNullable (Java 9+)
        long count = Stream.of(1, 2, null, 3, null, 4)
            .flatMap(Stream::ofNullable)
            .count();
        System.out.println("非空数量: " + count);  // 4

        // 8. Collectors.teeing (Java 12+)
        record Stats(double sum, int count) {}
        Stats stats = Stream.of(1.0, 2.0, 3.0, 4.0, 5.0)
            .collect(Collectors.teeing(
                Collectors.summingDouble(Double::doubleValue),
                Collectors.counting(),
                (s, c) -> new Stats(s, c.intValue())
            ));
        System.out.println("统计: " + stats);

        // 9. groupingBy 下游收集器组合
        record Sale(String category, double amount) {}
        Map<String, Double> avgByCategory = Stream.of(
            new Sale("Books", 50),
            new Sale("Books", 30),
            new Sale("Electronics", 200),
            new Sale("Electronics", 300)
        ).collect(Collectors.groupingBy(
            Sale::category,
            Collectors.averagingDouble(Sale::amount)
        ));
        System.out.println("分类平均: " + avgByCategory);

        // 10. collectingAndThen 后处理
        Map<String, List<Sale>> unmodifiable = Stream.of(
            new Sale("Books", 50),
            new Sale("Electronics", 200)
        ).collect(Collectors.collectingAndThen(
            Collectors.groupingBy(Sale::category),
            Collections::unmodifiableMap
        ));
    }
}

5.10 完整案例：基于函数式的领域建模

package com.example.fp.domain;

import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 基于函数式思维的电商领域模型
 */
public class FunctionalECommerce {

    // 不可变值对象
    record Product(Long id, String name, BigDecimal price, String category) {}
    record Customer(Long id, String name, String tier) {}
    record OrderItem(Product product, int quantity) {
        BigDecimal subtotal() {
            return product.price().multiply(BigDecimal.valueOf(quantity));
        }
    }
    record Order(Long id, Customer customer, List<OrderItem> items,
                 LocalDateTime createdAt, String status) {
        BigDecimal total() {
            return items.stream()
                .map(OrderItem::subtotal)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        }
    }

    // 函数式服务
    static class OrderService {
        private final List<Order> orders;

        OrderService(List<Order> orders) {
            this.orders = orders;
        }

        // 高阶查询函数
        public List<Order> queryOrders(Predicate<Order> predicate,
                                       Comparator<Order> sorter,
                                       int limit) {
            return orders.stream()
                .filter(predicate)
                .sorted(sorter)
                .limit(limit)
                .collect(Collectors.toList());
        }

        // 函数组合的查询构建器
        public static class OrderQueryBuilder {
            private Predicate<Order> predicate = o -> true;
            private Comparator<Order> sorter = Comparator.comparing(Order::createdAt);
            private int limit = Integer.MAX_VALUE;

            public OrderQueryBuilder where(Predicate<Order> p) {
                this.predicate = this.predicate.and(p);
                return this;
            }

            public OrderQueryBuilder orderBy(Comparator<Order> s) {
                this.sorter = s;
                return this;
            }

            public OrderQueryBuilder limit(int n) {
                this.limit = n;
                return this;
            }

            public Predicate<Order> buildPredicate() {
                return predicate;
            }

            public Comparator<Order> buildSorter() {
                return sorter;
            }

            public int buildLimit() {
                return limit;
            }
        }

        // 统计报告
        public Map<String, BigDecimal> revenueByCategory() {
            return orders.stream()
                .filter(o -> "COMPLETED".equals(o.status()))
                .flatMap(o -> o.items().stream())
                .collect(Collectors.groupingBy(
                    item -> item.product().category(),
                    Collectors.reducing(
                        BigDecimal.ZERO,
                        OrderItem::subtotal,
                        BigDecimal::add
                    )
                ));
        }

        // 客户消费排名
        public List<Map.Entry<String, BigDecimal>> topCustomers(int n) {
            return orders.stream()
                .filter(o -> "COMPLETED".equals(o.status()))
                .collect(Collectors.groupingBy(
                    o -> o.customer().name(),
                    Collectors.reducing(
                        BigDecimal.ZERO,
                        Order::total,
                        BigDecimal::add
                    )
                ))
                .entrySet().stream()
                .sorted(Map.Entry.<String, BigDecimal>comparingByValue().reversed())
                .limit(n)
                .collect(Collectors.toList());
        }
    }

    public static void main(String[] args) {
        Product book = new Product(1L, "Java编程思想", new BigDecimal("99.00"), "Books");
        Product laptop = new Product(2L, "MacBook Pro", new BigDecimal("12999.00"), "Electronics");
        Product phone = new Product(3L, "iPhone", new BigDecimal("6999.00"), "Electronics");

        Customer alice = new Customer(1L, "Alice", "GOLD");
        Customer bob = new Customer(2L, "Bob", "SILVER");

        List<Order> orders = List.of(
            new Order(1L, alice, List.of(
                new OrderItem(book, 2),
                new OrderItem(laptop, 1)
            ), LocalDateTime.now().minusDays(5), "COMPLETED"),
            new Order(2L, bob, List.of(
                new OrderItem(phone, 1)
            ), LocalDateTime.now().minusDays(3), "COMPLETED"),
            new Order(3L, alice, List.of(
                new OrderItem(book, 1)
            ), LocalDateTime.now().minusDays(1), "PENDING")
        );

        OrderService service = new OrderService(orders);

        // 使用查询构建器
        OrderService.OrderQueryBuilder builder = new OrderService.OrderQueryBuilder()
            .where(o -> "COMPLETED".equals(o.status()))
            .where(o -> o.customer().tier().equals("GOLD"))
            .orderBy(Comparator.comparing(Order::total).reversed())
            .limit(10);

        List<Order> goldCompleted = service.queryOrders(
            builder.buildPredicate(),
            builder.buildSorter(),
            builder.buildLimit()
        );
        System.out.println("Gold 客户已完成订单: " + goldCompleted.size());

        // 分类收入
        System.out.println("分类收入: " + service.revenueByCategory());

        // Top 客户
        System.out.println("Top 客户: " + service.topCustomers(5));
    }
}

6. 对比分析：函数式 vs 命令式

6.1 代码风格对比

场景：统计每个部门的平均薪资，并按薪资降序排列。

// 命令式风格
Map<String, List<Employee>> byDept = new HashMap<>();
for (Employee e : employees) {
    byDept.computeIfAbsent(e.getDepartment(), k -> new ArrayList<>()).add(e);
}
Map<String, Double> avgSalary = new HashMap<>();
for (Map.Entry<String, List<Employee>> entry : byDept.entrySet()) {
    double sum = 0;
    for (Employee e : entry.getValue()) {
        sum += e.getSalary();
    }
    avgSalary.put(entry.getKey(), sum / entry.getValue().size());
}
List<Map.Entry<String, Double>> sorted = new ArrayList<>(avgSalary.entrySet());
sorted.sort((e1, e2) -> Double.compare(e2.getValue(), e1.getValue()));

// 函数式风格
List<Map.Entry<String, Double>> result = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.averagingDouble(Employee::getSalary)
    ))
    .entrySet().stream()
    .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
    .collect(Collectors.toList());

对比维度：

6.2 性能对比：Stream vs for 循环

// 测试数据：1,000,000 个整数
List<Integer> data = IntStream.rangeClosed(1, 1_000_000).boxed().collect(Collectors.toList());

// 1. 传统 for 循环
long sumFor = 0;
for (int n : data) {
    if (n % 2 == 0) {
        sumFor += n * n;
    }
}

// 2. 串行 Stream
long sumStream = data.stream()
    .filter(n -> n % 2 == 0)
    .mapToLong(n -> (long) n * n)
    .sum();

// 3. 并行 Stream
long sumParallel = data.parallelStream()
    .filter(n -> n % 2 == 0)
    .mapToLong(n -> (long) n * n)
    .sum();

性能数据（JMH 基准测试，吞吐量 ops/ms）：

结论：

1. 小数据量：for 循环最快，Stream 有装箱与流水线开销。
2. 大数据量：并行 Stream 接近 for 循环，但需考虑并行开销。
3. 原始类型流（IntStream）能显著降低装箱开销，性能接近 for 循环。

6.3 Lambda vs 匿名内部类

// 匿名内部类
Comparator<String> cmp1 = new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
};

// Lambda
Comparator<String> cmp2 = (s1, s2) -> Integer.compare(s1.length(), s2.length());

底层差异：

6.4 函数式接口 vs 自定义接口

// 方案 A：使用标准函数式接口
Function<User, String> getName = User::getName;

// 方案 B：自定义接口
@FunctionalInterface
interface UserToString extends Function<User, String> {
    // 可添加默认方法
}
UserToString getName2 = User::getName;

何时使用自定义接口：

1. 需要附加语义（如 UserToString 表达”将用户转为字符串”的领域语义）。
2. 需要扩展默认方法（如组合、校验）。
3. 需要在 API 文档中明确类型约束。
4. 自定义接口的缺点：与标准库互操作需适配。

6.5 Stream vs Reactive Streams

7. 陷阱与反模式

7.1 反模式：Stream 重复消费

// 反模式：Stream 只能消费一次
Stream<String> stream = Stream.of("a", "b", "c");
stream.forEach(System.out::println);
stream.map(String::toUpperCase).forEach(System.out::println);  // IllegalStateException!

// 正确做法：使用 Supplier 延迟创建
Supplier<Stream<String>> streamSupplier = () -> Stream.of("a", "b", "c");
streamSupplier.get().forEach(System.out::println);
streamSupplier.get().map(String::toUpperCase).forEach(System.out::println);

7.2 反模式：并行流共享可变状态

// 反模式：并行流修改共享集合
List<Integer> results = new ArrayList<>();
IntStream.rangeClosed(1, 1000).parallel()
    .forEach(results::add);  // ArrayList 非线程安全，可能丢失数据

// 正确做法 1：使用线程安全集合
List<Integer> safeResults = Collections.synchronizedList(new ArrayList<>());
IntStream.rangeClosed(1, 1000).parallel()
    .forEach(safeResults::add);

// 正确做法 2：使用 collect（推荐）
List<Integer> collected = IntStream.rangeClosed(1, 1000).parallel()
    .boxed()
    .collect(Collectors.toList());

// 正确做法 3：使用 reduce
List<Integer> reduced = IntStream.rangeClosed(1, 1000).parallel()
    .boxed()
    .reduce(
        new ArrayList<>(),
        (list, n) -> { list.add(n); return list; },
        (l1, l2) -> { l1.addAll(l2); return l1; }
    );

7.3 反模式：Lambda 中的副作用

// 反模式：Lambda 修改外部可变状态
List<String> names = new ArrayList<>();
users.stream()
    .filter(u -> u.getAge() > 18)
    .forEach(u -> names.add(u.getName()));  // 副作用

// 正确做法：使用 collect
List<String> adultNames = users.stream()
    .filter(u -> u.getAge() > 18)
    .map(User::getName)
    .collect(Collectors.toList());

7.4 反模式：过度嵌套的 Stream

// 反模式：过度嵌套，可读性差
List<String> result = data.stream()
    .flatMap(a -> a.getSubItems().stream()
        .flatMap(b -> b.getTags().stream()
            .filter(tag -> tag.length() > 3)
            .map(tag -> tag.toUpperCase())))
    .distinct()
    .collect(Collectors.toList());

// 正确做法：抽取中间方法
List<String> result = data.stream()
    .map(this::extractTags)  // 抽取为方法
    .flatMap(List::stream)
    .filter(tag -> tag.length() > 3)
    .map(String::toUpperCase)
    .distinct()
    .collect(Collectors.toList());

7.5 反模式：在 forEach 中执行 I/O

// 反模式：forEach 中执行数据库操作
users.stream().forEach(u -> {
    saveToDatabase(u);  // 串行 I/O，性能差
});

// 正确做法 1：批量处理
List<User> batch = users.stream().collect(Collectors.toList());
saveAllToDatabase(batch);

// 正确做法 2：并行流（如果 I/O 可并行）
users.parallelStream().forEach(this::saveToDatabase);
// 或使用 CompletableFuture
List<CompletableFuture<Void>> futures = users.stream()
    .map(u -> CompletableFuture.runAsync(() -> saveToDatabase(u)))
    .collect(Collectors.toList());
futures.forEach(CompletableFuture::join);

7.6 反模式：使用 peek 修改状态

// 反模式：peek 用于副作用（语义不明确）
List<User> users = rawUsers.stream()
    .peek(u -> u.setProcessed(true))  // 修改对象状态
    .collect(Collectors.toList());

// 正确做法：使用 map 进行转换
List<User> users = rawUsers.stream()
    .map(u -> u.withProcessed(true))  // 返回新对象
    .collect(Collectors.toList());

7.7 反模式：忽视受检异常

// 反模式：Lambda 中抛出受检异常
files.stream()
    .map(Files::readString)  // 抛出 IOException，编译错误！

// 正案 1：包装为非受检异常
files.stream()
    .map(file -> {
        try {
            return Files.readString(file);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    })
    .collect(Collectors.toList());

// 方案 2：抽取工具方法
files.stream()
    .map(this::readStringSafely)
    .collect(Collectors.toList());

// 方案 3：使用 Either Monad（需要 Vavr 等库）

7.8 反模式：Collectors.toMap 键冲突

// 反模式：toMap 遇到重复键抛异常
Map<String, Integer> nameToAge = users.stream()
    .collect(Collectors.toMap(User::getName, User::getAge));  // DuplicateKeyException

// 正确做法 1：提供合并函数
Map<String, Integer> nameToAge = users.stream()
    .collect(Collectors.toMap(
        User::getName,
        User::getAge,
        (a, b) -> a  // 保留第一个
    ));

// 正确做法 2：分组为 List
Map<String, List<Integer>> nameToAges = users.stream()
    .collect(Collectors.groupingBy(
        User::getName,
        Collectors.mapping(User::getAge, Collectors.toList())
    ));

7.9 反模式：Optional 滥用

// 反模式 1：Optional 作为字段
class User {
    private Optional<String> nickname;  // 序列化问题，内存浪费
}

// 反模式 2：Optional 作为参数
void setName(Optional<String> name) {  // 增加调用复杂度
    this.name = name.orElse("匿名");
}

// 正确做法：使用方法重载或 nullable
void setName(String name) {
    this.name = name != null ? name : "匿名";
}
void setName() {
    setName("匿名");
}

7.10 反模式：方法引用过度使用

// 反模式：方法引用降低可读性
list.stream()
    .map(Object::toString)
    .map(String::trim)
    .map(String::toLowerCase)
    .forEach(System.out::println);

// 正确做法：复杂场景使用 Lambda 提升可读性
list.stream()
    .map(obj -> obj.toString().trim().toLowerCase())
    .forEach(System.out::println);

8. 工程实践：函数式编程的项目落地

8.1 项目结构建议

src/main/java/com/example/
├── domain/                  # 领域模型（不可变值对象）
│   ├── User.java            # record User(...)
│   └── Order.java
├── service/                 # 函数式服务
│   ├── UserService.java
│   └── OrderService.java
├── functional/              # 自定义函数式接口
│   ├── Transformer.java
│   └── ThrowingFunction.java  # 处理受检异常
├── collector/               # 自定义收集器
│   └── PercentileCollector.java
└── util/                    # 函数式工具
    └── StreamUtils.java

8.2 处理受检异常的工具

@FunctionalInterface
public interface ThrowingFunction<T, R, E extends Exception> {
    R apply(T t) throws E;

    static <T, R, E extends Exception> Function<T, R> unchecked(
            ThrowingFunction<T, R, E> function) {
        return t -> {
            try {
                return function.apply(t);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
    }
}

// 使用
List<String> contents = files.stream()
    .map(ThrowingFunction.unchecked(Files::readString))
    .collect(Collectors.toList());

8.3 函数式缓存

public class MemoizedFunction<T, R> implements Function<T, R> {
    private final Function<T, R> delegate;
    private final Map<T, R> cache = new ConcurrentHashMap<>();

    public MemoizedFunction(Function<T, R> delegate) {
        this.delegate = delegate;
    }

    @Override
    public R apply(T t) {
        return cache.computeIfAbsent(t, delegate);
    }
}

// 使用
Function<Integer, Integer> slowSquare = x -> {
    try { Thread.sleep(100); } catch (InterruptedException e) {}
    return x * x;
};
Function<Integer, Integer> memoized = new MemoizedFunction<>(slowSquare);

long start = System.currentTimeMillis();
memoized.apply(5);  // 100ms
memoized.apply(5);  // <1ms（缓存命中）
memoized.apply(6);  // 100ms

8.4 函数式重试

public class Retry {
    public static <T> Supplier<T> withRetry(Supplier<T> action, int maxRetries) {
        return () -> {
            RuntimeException lastException = null;
            for (int i = 0; i <= maxRetries; i++) {
                try {
                    return action.get();
                } catch (RuntimeException e) {
                    lastException = e;
                    if (i < maxRetries) {
                        try {
                            Thread.sleep((long) Math.pow(2, i) * 100);
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                        }
                    }
                }
            }
            throw lastException;
        };
    }
}

// 使用
String result = Retry.withRetry(() -> callRemoteService(), 3).get();

8.5 函数式配置

public class FunctionalRouter {
    private final Map<String, Function<Request, Response>> routes = new HashMap<>();

    public FunctionalRouter route(String path, Function<Request, Response> handler) {
        routes.put(path, handler);
        return this;
    }

    public Response handle(Request request) {
        return routes.getOrDefault(request.path(), req ->
            new Response(404, "Not Found")).apply(request);
    }
}

// 使用
FunctionalRouter router = new FunctionalRouter()
    .route("/users", this::listUsers)
    .route("/orders", this::listOrders)
    .route("/health", req -> new Response(200, "OK"));

8.6 测试函数式代码

class FunctionalTest {
    @Test
    void testPipeline() {
        // 给定
        List<User> users = List.of(
            new User("Alice", 25),
            new User("Bob", 17),
            new User("Charlie", 30)
        );

        // 当
        List<String> result = users.stream()
            .filter(u -> u.age() > 18)
            .sorted(Comparator.comparing(User::name))
            .map(User::name)
            .collect(Collectors.toList());

        // 则
        assertEquals(List.of("Alice", "Charlie"), result);
    }

    @Test
    void testPureFunction() {
        Function<Integer, Integer> square = x -> x * x;

        // 引用透明性：多次调用结果相同
        assertEquals(25, square.apply(5));
        assertEquals(25, square.apply(5));
        assertEquals(25, square.apply(5));
    }

    @Test
    void testParallelStream() {
        List<Integer> data = IntStream.rangeClosed(1, 10000).boxed().collect(Collectors.toList());

        long sum = data.parallelStream()
            .mapToLong(Integer::longValue)
            .sum();

        assertEquals(50005000L, sum);
    }
}

9. 案例研究：主流框架的函数式实践

9.1 Spring Framework 的函数式风格

Spring 5+ 大量采用函数式风格：

// 函数式路由（Spring WebFlux）
@Configuration
public class FunctionalRoutes {
    @Bean
    public RouterFunction<ServerResponse> userRoutes(UserHandler handler) {
        return RouterFunctions.route()
            .GET("/users/{id}", handler::getUser)
            .GET("/users", handler::listUsers)
            .POST("/users", handler::createUser)
            .build();
    }
}

// 函数式 Bean 注册（Spring 5+）
GenericApplicationContext context = new GenericApplicationContext();
context.registerBean(UserService.class);
context.refresh();

// Spring Security 函数式 DSL
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form.loginPage("/login"))
            .build();
    }
}