Java8函数式编程之纯函数_java纯函数式编程-优快云博客

纯函数是一个至关重要的概念，理解它对于掌握函数式编程的精髓大有裨益。

一、纯函数的定义

纯函数是指满足以下两个条件的函数：

相同输入，总是返回相同输出：无论何时调用，只要传入的参数相同，返回的结果必定完全相同。它的执行结果不依赖于任何外部状态或上下文。
无副作用：函数的执行不会对外部世界产生任何可观察的影响。这意味着它不会修改任何外部状态（如全局变量、静态变量、传入的引用参数等），也不会触发任何外部操作（如 IO 操作、向控制台打印日志、抛出异常等）。

简单来说，纯函数就像一个数学函数，比如 f(x) = x + 1。你传入 5，它永远返回 6。它的计算过程只依赖于输入，并且除了返回值之外，不做任何其他事情。

二、纯函数的特性详解

1. 引用透明性

这是纯函数的一个必然结果。如果一个函数是纯的，那么它的调用表达式可以被其返回值替换，而不会改变程序的行为。

示例：

// 纯函数
int add(int a, int b) {
    return a + b;
}

// 在代码中
int result = add(2, 3); // 结果是 5
System.out.println(result);

因为 add(2, 3) 永远返回 5，所以我们可以安全地将代码重写为：

System.out.println(5); // 程序的行为完全不变

这种可替换性使得代码更容易推理和验证。

2. 无状态性

纯函数的执行不依赖于任何外部或隐藏的状态。它的输出完全由输入决定。这使得纯函数是线程安全的。多个线程可以同时调用同一个纯函数而无需任何同步机制，因为它们不会竞争修改共享资源。

3. 可缓存性

由于对于相同的输入，纯函数总是返回相同的结果，因此我们可以对结果进行缓存（或称为“记忆化”）。在第一次计算完结果后，将其缓存起来。下次再用相同的参数调用时，可以直接返回缓存的结果，跳过计算过程，从而显著提升性能。

简单缓存示例思路：

import java.util.HashMap;
import java.util.Map;

public class CachedPureFunction {
    private final Map<String, Integer> cache = new HashMap<>();

    // 一个计算密集型的纯函数（假设）
    int expensiveCalculation(int x, int y) {
        // 生成缓存键
        String key = x + "," + y;
        
        // 先检查缓存
        return cache.computeIfAbsent(key, k -> {
            System.out.println("Calculating for: " + key); // 这只是为了演示，实际纯函数不应有输出
            // 模拟一个昂贵的计算，例如复杂数学运算
            return x * y + x + y; // 这是一个纯操作
        });
    }
}

三、Java 8 中的纯函数实践

Java 8 的函数式接口和 Lambda 表达式是编写纯函数的绝佳工具。

1. 符合纯函数定义的 Lambda 表达式

// 纯函数：无状态，无副作用，输出只取决于输入
Function<Integer, Integer> square = x -> x * x;
BinaryOperator<Integer> add = (a, b) -> a + b;

// 在 Stream API 中使用
List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
List<Integer> squares = numbers.stream()
                               .map(x -> x * x) // 这里的 map 操作接受一个纯函数
                               .collect(Collectors.toList());
// squares 是 [1, 4, 9, 16]

上面的 x -> x * x 就是一个典型的纯函数 Lambda 表达式。

2. 非纯函数（反例）

// 非纯函数：依赖于外部状态（计数器）
int counter = 0;
Function<Integer, Integer> impureAdd = x -> {
    counter++; // 副作用：修改了外部变量
    return x + counter; // 输出不仅取决于 x，还取决于被修改的 counter
};

// 第一次调用：result1 = 1 + 1 = 2
int result1 = impureAdd.apply(1);
// 第二次调用：result2 = 1 + 2 = 3 (相同输入 1，得到了不同的输出)
int result2 = impureAdd.apply(1);


// 非纯函数：产生副作用（输出到控制台）
Function<Integer, Integer> withSideEffect = x -> {
    System.out.println("Received " + x); // 副作用：IO操作
    return x * 2;
};


// 非纯函数：修改了传入的参数（引用类型）
Consumer<List<String>> impureSorter = list -> {
    Collections.sort(list); // 副作用：修改了传入的集合
};
List<String> myList = new ArrayList<>(Arrays.asList("z", "a", "m"));
impureSorter.accept(myList); // myList 被永久地排序了

四、为什么追求纯函数？

易于理解和推理：纯函数不依赖于隐蔽的外部状态，也不改变外部世界。你只需要关注它的输入和输出，而无需担心函数调用时外部的上下文环境，降低了代码的认知复杂度。
易于测试：测试纯函数非常简单。你不需要复杂的 Setup 和 Mock，只需要给定输入，断言输出即可。测试用例是完全隔离和确定的。
线程安全：纯函数天然是线程安全的，避免了多线程环境下最棘手的竞态条件和同步问题。
可缓存性和可优化性：正如前面所述，编译器或运行时可以利用纯函数的特性进行积极的优化，如延迟计算、并行计算和缓存。
更好的组合性：纯函数可以像乐高积木一样轻松组合成更复杂的操作，因为每个函数都只完成一个确定的、无副作用的计算。functionC = functionA.andThen(functionB) 这样的组合会非常可靠。

五、现实世界的注意事项

在实际的业务开发中，完全避免副作用是不可能的。程序终究需要与数据库交互、调用外部 API、写入日志文件、接收用户输入等（这些都是副作用）。

函数式编程的理念不是消除副作用，而是 “将副作用推到系统的边缘”。

核心业务逻辑：尽量使用纯函数来构建。这部分代码应该是无副作用的、确定性的、易于测试的。
IO 操作、状态变更：将这些不可避免的副作用限制在特定的、易于监控的范围内（例如，在 Controller 层进行数据库调用，在特定的服务类中写日志）。

这种架构使得应用程序的大部分代码（核心领域模型）是纯的、稳定的，而将不纯的部分隔离在外部，从而大大提高代码的质量和可维护性。

总结

特性	纯函数	非纯函数
输出确定性	相同输入，总是相同输出	相同输入，可能不同输出
副作用	无	有（修改外部状态、IO 等）
引用透明性	是	否
可缓存性	高	低或不可缓存
线程安全性	天然安全	需要同步机制
测试难度	低（只需断言输入输出）	高（需要模拟环境/状态）