三分钟掌握 BiFunction

news/2025/4/1 8:21:49/文章来源:https://www.cnblogs.com/bestjosephine/p/18800055

三分钟掌握 BiFunction

Java中的BiFunction接口是Java 8引入的一个核心函数式接口，用于表示接受两个输入参数并生成一个结果的操作。它属于java.util.function包，为Lambda表达式和方法引用提供了更灵活的支持。以下是对BiFunction接口的详细解析：

1. 接口定义

@FunctionalInterface
public interface BiFunction<T, U, R> {R apply(T t, U u); // 核心方法：接受T和U类型参数，返回R类型结果// 组合方法：将当前BiFunction的结果传递给另一个Function处理default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t, U u) -> after.apply(apply(t, u));}
}

泛型参数：
- T：第一个输入参数的类型。
- U：第二个输入参数的类型。
- R：返回结果的类型。
函数式方法：apply(T t, U u) 是唯一的抽象方法。
组合方法：andThen 允许将结果传递给另一个Function进行后续处理。

2. 方法的具体工作流程

方法一：`R apply(T t, U u);`

flowchart LRA[输入参数 T] --> C[BiFunction]B[输入参数 U] --> CC -->|apply 处理| D[结果 R]

方法二：`default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after)`

1. 方法签名解析

<V>：声明新的泛型类型，表示最终返回结果的类型。
BiFunction<T, U, V>：返回一个新的 BiFunction，它接收 T 和 U 参数，最终返回 V 类型。
Function<? super R, ? extends V>：
- ? super R：允许 after 函数接收 R 或其父类型（协变性）。
- ? extends V：允许 after 函数返回 V 或其子类型（逆变性）。
- 这种设计增强了方法的灵活性（遵循 PECS原则：Producer-Extends, Consumer-Super）。

2. 实现逻辑

Objects.requireNonNull(after);
return (T t, U u) -> after.apply(apply(t, u));

步骤分解：
1. 空指针检查：Objects.requireNonNull(after) 防止后续操作因 after 为 null 而崩溃。
2. 调用原始 BiFunction：通过 apply(t, u) 得到中间结果（类型 R）。
3. 传递结果给 after：将中间结果作为输入，调用 after.apply()，得到最终结果（类型 V）。
链式操作：通过组合多个函数，形成 处理流水线。

3. 核心特性

（1）函数式编程的核心组件

BiFunction 用于将两个值转换为一个新值，是函数组合和链式操作的基础。
与单参数的Function接口不同，BiFunction明确支持双参数操作。

（2）与 BinaryOperator 的关系

BinaryOperator<T> 是 BiFunction<T, T, T> 的子接口，专用于两个同类型输入和同类型输出的场景。
```
BinaryOperator<Integer> add = (a, b) -> a + b;
```

（3）组合操作（andThen）

场景：计算两个数的平方和后，转换为十六进制字符串。

BiFunction<Integer, Integer, Integer> sumSquares = (a, b) -> a*a + b*b;
Function<Integer, String> toHex = Integer::toHexString;// 组合两个函数
BiFunction<Integer, Integer, String> pipeline = sumSquares.andThen(toHex);String result = pipeline.apply(3, 4); // 3² + 4² = 25 → 0x19 → "19"

执行流程：

flowchart LRA[输入 T=3] --> C[sumSquares]B[输入 U=4] --> CC -->|中间结果 R=25| D[toHex]D -->|最终结果 V=19| E[输出]

4. 使用场景

（1）简单运算

BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
int sum = add.apply(5, 3); // 结果：8

（2）对象操作
合并两个对象的属性：

BiFunction<String, String, String> concat = (s1, s2) -> s1 + s2;
String fullName = concat.apply("John", "Doe"); // "JohnDoe"

（3）集合处理
在流式操作中合并两个集合：

BiFunction<List<String>, List<String>, List<String>> mergeLists = (list1, list2) -> Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList());

（4）复杂业务逻辑
例如，根据用户输入和数据库数据生成报告：

BiFunction<UserInput, DatabaseData, Report> generateReport = (input, data) -> new Report(input.filter(data), data.getTimestamp());

5. 注意事项

（1）异常处理

apply方法不声明受检异常（checked exceptions），若操作可能抛出异常，需在Lambda内部处理：

BiFunction<String, String, Integer> safeParse = (s1, s2) -> {try {return Integer.parseInt(s1) + Integer.parseInt(s2);} catch (NumberFormatException e) {return 0;}
};

（2）空安全性

对输入参数进行null检查以避免NullPointerException。

（3）性能考量

在性能敏感场景中，避免过度复杂的链式操作（如多层andThen），可能影响可读性和效率。

6. 对比其他接口

接口	输入参数	返回类型	典型用例
`Function<T, R>`	1 (T)	R	单个值的转换，如`String::length`
`BiFunction<T, U, R>`	2 (T, U)	R	合并两个值，如坐标相加
`BinaryOperator<T>`	2 (T, T)	T	两个同类型操作，如`Integer::sum`