在 Java 8 引入的函数式编程范式中，Function<T, R> 接口是核心组件之一，它代表接受一个参数并产生结果的函数。而 andThen 方法则提供了强大的函数组合能力，允许将多个函数串联成一个复杂的处理流程。
本文将从基础概念入手，逐步深入探讨 Function 接口及其组合机制的原理与应用。
一、Function 接口基础
Function<T, R> 是一个函数式接口，位于 java.util.function 包中，其核心定义如下：
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
类型参数：
T：输入参数的类型R：返回结果的类型
核心方法：
apply(T t)：执行函数逻辑，返回结果andThen(Function)：函数组合，先执行当前函数，再执行后续函数compose(Function)：函数组合，先执行前置函数，再执行当前函数identity()：返回一个始终返回输入参数的函数
二、基础用法示例
1. 简单函数实现
// 将字符串转换为大写
Function<String, String> toUpperCase = s -> s.toUpperCase();
String result = toUpperCase.apply("hello"); // 输出：HELLO
// 将字符串转换为其长度
Function<String, Integer> lengthFunction = s -> s.length();
Integer length = lengthFunction.apply("hello"); // 输出：5
2. 自定义函数实现
class EmailValidator implements Function<String, Boolean> {
@Override
public Boolean apply(String email) {
return email != null && email.contains("@");
}
}
// 使用自定义函数
Function<String, Boolean> validator = new EmailValidator();
boolean isValid = validator.apply("test@example.com"); // 输出：true
三、andThen 方法详解
andThen 方法允许将多个 Function 组合成一个新的 Function，执行顺序为：先执行当前 Function，再执行传入的 Function。
1. 基础组合示例
// 定义两个简单函数 Function<Integer, Integer> multiplyByTwo = num -> num * 2; Function<Integer, Integer> addTen = num -> num + 10; // 组合函数：先乘以2，再加10 Function<Integer, Integer> combined = multiplyByTwo.andThen(addTen); int result = combined.apply(5); // 执行流程：5 * 2 + 10 = 20
2. 复杂组合示例
// 定义三个函数
Function<String, String> removeWhitespace = s -> s.replaceAll("\\s", "");
Function<String, String> toUpperCase = s -> s.toUpperCase();
Function<String, String> addPrefix = s -> "[PREFIX] " + s;
// 组合多个函数
Function<String, String> pipeline = removeWhitespace
.andThen(toUpperCase)
.andThen(addPrefix);
String result = pipeline.apply(" hello world ");
// 执行流程：" hello world " -> "helloworld" -> "HELLOWORLD" -> "[PREFIX] HELLOWORLD"
四、compose 方法与 andThen 的对比
compose 方法同样用于函数组合，但执行顺序与 andThen 相反：先执行传入的 Function，再执行当前 Function。
Function<Integer, Integer> multiplyByTwo = num -> num * 2; Function<Integer, Integer> addTen = num -> num + 10; // 使用 andThen：先乘2，再加10 Function<Integer, Integer> combined1 = multiplyByTwo.andThen(addTen); int result1 = combined1.apply(5); // 计算：(5 * 2) + 10 = 20 // 使用 compose：先加10，再乘2 Function<Integer, Integer> combined2 = multiplyByTwo.compose(addTen); int result2 = combined2.apply(5); // 计算：(5 + 10) * 2 = 30
执行顺序总结：
f.andThen(g)等价于g(f(x))f.compose(g)等价于f(g(x))
五、在 Stream API 中的应用
Function 接口在 Stream API 中被广泛用于映射操作：
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
public class StreamMapExample {
public static void main(String[] args) {
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 定义函数：转换为大写并截取前3个字符
Function<String, String> processWord = s -> s.toUpperCase().substring(0, 3);
// 在 Stream 中使用函数
List<String> result = words.stream()
.map(processWord)
.collect(Collectors.toList());
System.out.println(result); // 输出：[APP, BAN, CHE]
}
}
六、高级应用场景
1. 动态构建函数链
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
public class DynamicFunctionChain {
public static void main(String[] args) {
// 动态构建函数链
List<Function<String, String>> functions = new ArrayList<>();
functions.add(s -> s.replace(" ", "_"));
functions.add(String::toUpperCase);
functions.add(s -> "[" + s + "]");
// 组合所有函数
Function<String, String> pipeline = functions.stream()
.reduce(Function.identity(), Function::andThen);
String result = pipeline.apply("hello world");
// 输出：[HELLO_WORLD]
}
}
2. 函数工厂模式
import java.util.function.Function;
public class FunctionFactory {
// 创建一个将字符串重复指定次数的函数
public static Function<String, String> repeatFunction(int times) {
return s -> {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < times; i++) {
sb.append(s);
}
return sb.toString();
};
}
public static void main(String[] args) {
Function<String, String> triple = repeatFunction(3);
String result = triple.apply("abc"); // 输出：abcabcabc
}
}
七、最佳实践与注意事项
避免函数链过长：
- 过长的函数链会降低代码可读性，建议将复杂逻辑分解为多个命名清晰的函数
处理异常：
- Function 接口的
apply方法不声明检查异常，若需要处理异常，可考虑使用自定义函数式接口
使用泛型上限和下限：
- 在组合函数时，合理使用
? super T和? extends R确保类型安全
利用 identity () 方法：
- 在动态组合函数时，
Function.identity()可作为初始值，避免空指针问题
八、总结
Java 的 Function 接口与 andThen 组合机制为函数式编程提供了强大的工具，通过合理运用可以：
- 简化代码：避免编写冗长的嵌套方法调用
- 提高可维护性：将复杂逻辑分解为独立的函数单元
- 增强灵活性：支持动态组合函数，适应不同业务场景
- 优化数据流处理：在 Stream API 中高效执行映射操作
在实际开发中，建议将常用的函数定义为静态常量或通过工厂方法生成，并通过组合操作构建更高级的业务逻辑，从而使代码更加简洁、灵活和可维护。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持。
