Java 中的 BiFunction 与 BinaryOperator使用示例

更新时间：2025年09月11日 16:33:07 作者：潜意识Java

在Java8引入的函数式编程特性中,BiFunction和BinaryOperator是两个非常重要的函数式接口,它们在处理二元操作和函数组合时发挥着关键作用,下面将从基础概念、核心区别、实际应用等多个维度深入解析这两个接口,感兴趣的朋友跟随小编一起看看吧

一、BiFunction 接口详解

BiFunction 是 Java 函数式编程中处理二元输入的基础接口，它定义了接收两个参数并返回一个结果的函数行为。

1. 基本定义与语法

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

T：第一个输入参数的类型
U：第二个输入参数的类型
R：返回结果的类型
apply 方法：接收两个参数并返回计算结果

2. 使用示例

// 示例1：简单的数值计算
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
System.out.println(add.apply(5, 3)); // 输出：8
// 示例2：字符串拼接
BiFunction<String, String, String> concat = (str1, str2) -> str1 + str2;
System.out.println(concat.apply("Hello, ", "World!")); // 输出：Hello, World!
// 示例3：对象属性计算
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}
// 创建Person对象的BiFunction
BiFunction<String, Integer, Person> personCreator = Person::new;
Person person = personCreator.apply("Alice", 30);
System.out.println(person); // 输出：Person{name='Alice', age=30}

3. 常用默认方法

BiFunction 接口提供了两个实用的默认方法，用于函数组合：

andThen(Function<? super R, ? extends V> after)：将当前函数的结果作为另一个函数的输入
compose(Function<? super T, ? extends U> before)：将另一个函数的结果作为当前函数的第一个输入

// andThen示例：先相加再乘以2
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
Function<Integer, Integer> doubleValue = x -> x * 2;
BiFunction<Integer, Integer, Integer> addThenDouble = add.andThen(doubleValue);
System.out.println(addThenDouble.apply(5, 3)); // 输出：16
// compose示例：先将输入乘以2再相加
Function<Integer, Integer> doubleFirst = x -> x * 2;
BiFunction<Integer, Integer, Integer> doubleFirstThenAdd = add.compose(doubleFirst);
System.out.println(doubleFirstThenAdd.apply(5, 3)); // 输出：13（5*2 + 3 = 13）

二、BinaryOperator 接口详解

BinaryOperator 是 BiFunction 的子接口，专门用于处理两个相同类型输入并返回相同类型结果的场景，也被称为二元运算符。

1. 基本定义与语法

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
    // 继承自BiFunction的apply方法
    T apply(T t, T u);
    // 静态工厂方法
    static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        // 实现略
    }
    static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        // 实现略
    }
}

输入参数和返回值类型均为 T
继承自 BiFunction<T, T, T>，本质上是特殊化的 BiFunction

2. 使用示例

// 示例1：数值运算
BinaryOperator<Integer> add = (a, b) -> a + b;
System.out.println(add.apply(5, 3)); // 输出：8
// 示例2：字符串最长拼接（返回较长的字符串）
BinaryOperator<String> longestString = (str1, str2) -> 
    str1.length() > str2.length() ? str1 : str2;
System.out.println(longestString.apply("Hello", "World!")); // 输出：World!
// 示例3：使用静态工厂方法
List<Integer> numbers = Arrays.asList(10, 5, 8, 15, 3);
// 使用maxBy找到最大值
BinaryOperator<Integer> max = BinaryOperator.maxBy(Comparator.naturalOrder());
int result = numbers.stream()
        .reduce(0, max); // 初始值为0，可能需要调整逻辑
System.out.println(result); // 输出：15

3. 与 reduce 操作结合

BinaryOperator 最常见的应用场景是与 Stream.reduce() 方法结合，用于聚合操作：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 计算总和（使用Lambda表达式）
int sum = numbers.stream()
        .reduce(0, (a, b) -> a + b);
System.out.println("总和：" + sum); // 输出：15
// 计算总和（使用BinaryOperator）
BinaryOperator<Integer> addOperator = Integer::sum;
int sum2 = numbers.stream()
        .reduce(0, addOperator);
System.out.println("总和：" + sum2); // 输出：15
// 寻找最大值
Integer max = numbers.stream()
        .reduce(Integer::max)
        .orElse(0);
System.out.println("最大值：" + max); // 输出：5

三、BiFunction 与 BinaryOperator 的核心区别

特性	BiFunction<T, U, R>	BinaryOperator<T>
参数类型	两个不同类型的参数（T 和 U）	两个相同类型的参数（T 和 T）
返回值类型	可以与参数类型不同（R）	必须与参数类型相同（T）
接口关系	基础函数式接口	继承自 BiFunction 的子接口
典型应用场景	处理不同类型的输入组合	处理相同类型的二元运算（如聚合）
静态方法	无	提供 minBy 和 maxBy 静态工厂方法

示例对比：

当需要计算 String 和 Integer 的组合结果时，必须使用 BiFunction<String, Integer, ?>
当需要计算两个 Double 类型的最大值时，使用 BinaryOperator<Double> 更合适

四、实际应用场景

1. 数据转换与映射

// 将两个不同类型的数据转换为新类型
BiFunction<String, Integer, Map<String, Object>> userMapper = (name, age) -> {
    Map<String, Object> user = new HashMap<>();
    user.put("name", name);
    user.put("age", age);
    return user;
};
Map<String, Object> user = userMapper.apply("Bob", 25);
System.out.println(user); // 输出：{name=Bob, age=25}

2. 集合聚合操作

List<String> words = Arrays.asList("Java", "is", "powerful");
// 使用BinaryOperator连接字符串
String result = words.stream()
        .reduce("", (a, b) -> a + (a.isEmpty() ? "" : " ") + b);
System.out.println(result); // 输出：Java is powerful
// 更简洁的写法
String result2 = words.stream()
        .reduce("", String::concat);
System.out.println(result2); // 输出：Javaispowerful（无空格）

3. 函数式编程中的组合模式

// 定义多个BiFunction并组合使用
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
// 先相加再相乘：(a + b) * c
BiFunction<Integer, Integer, Integer> addThenMultiply = add.andThen(b -> multiply.apply(b, 2));
System.out.println(addThenMultiply.apply(3, 4)); // 输出：14（(3+4)*2=14）

4. 自定义对象操作

class Product {
    private String name;
    private double price;
    private int quantity;
    // 构造器、getter和setter略
    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + "', " +
                "price=" + price + ", " +
                "quantity=" + quantity +
                '}';
    }
}
// 计算产品总价值的BinaryOperator
BinaryOperator<Product> calculateTotalValue = (p1, p2) -> {
    double totalPrice = p1.getPrice() * p1.getQuantity() + p2.getPrice() * p2.getQuantity();
    return new Product("Total", totalPrice, 1); // 简化处理
};
Product product1 = new Product("Laptop", 899.99, 2);
Product product2 = new Product("Phone", 599.99, 3);
Product total = calculateTotalValue.apply(product1, product2);
System.out.println(total); // 输出总价值计算结果

五、总结与最佳实践

选择原则：
- 当两个输入参数类型不同或返回值类型与参数不同时，使用 BiFunction
- 当两个输入参数类型相同且返回值类型与参数相同时，优先使用 BinaryOperator
函数组合：
- 利用 andThen 和 compose 方法实现复杂逻辑的组合，避免嵌套 Lambda 表达式
与 Stream API 结合：
- 在 reduce、collect 等聚合操作中，BinaryOperator 是理想的参数选择
静态工厂方法：
- BinaryOperator 提供的 minBy 和 maxBy 方法可简化比较操作的实现

通过熟练掌握 BiFunction 和 BinaryOperator，开发者可以更高效地编写函数式代码，提升代码的可读性和简洁性，同时充分发挥 Java 8 + 函数式编程的优势。在实际项目中，合理运用这些接口能够有效减少样板代码，使逻辑更加清晰直观。

到此这篇关于Java 中的 BiFunction 与 BinaryOperator使用示例的文章就介绍到这了,更多相关java bifunction 与 binaryoperator内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

MyBatis-Plus 查询返回实体对象还是map
这篇文章主要介绍了MyBatis-Plus 查询返回实体对象还是map，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-09-09
通过反射实现Java下的委托机制代码详解
这篇文章主要介绍了通过反射实现Java下的委托机制代码详解，具有一定借鉴价值，需要的朋友可以参考下。
2017-12-12
Mybatis一对一延迟加载实现过程解析
这篇文章主要介绍了Mybatis一对一延迟加载实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-10-10
spring boot 使用@Async实现异步调用方法
本篇文章主要介绍了spring boot 使用@Async实现异步调用方法，具有一定的参考价值，有兴趣的可以了解一下。
2017-04-04
在ssm中使用ModelAndView跳转页面失效的解决
这篇文章主要介绍了在ssm中使用ModelAndView跳转页面失效的解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-05-05
SpringBoot如何使用validator框架优雅地校验参数
文章介绍了如何使用SpringValidation进行参数校验,包括引入依赖、@requestBody和@requestParam参数校验、统一异常处理、分组校验、嵌套校验、自定义校验、业务规则校验以及@Valid和@Validated的区别,同时,列举了常用的BeanValidation和HibernateValidator注解
2025-02-02
RabbitMQ中的Channel和Exchange详解
这篇文章主要介绍了RabbitMQ中的Channel和Exchange详解,创建和销毁TCP连接很耗时,打开太多TCP连接,耗操作系统资源,并发量大到一定程度,系统的吞吐量会降低,使用一个connection多channel的方式,可以提升连接的利用率,需要的朋友可以参考下
2023-08-08
java使用命令行打包JAR
如何把写好的Java程序打包为jar文件呢?下面说的就是java使用命令行打包JAR的方法
2013-11-11
Mybatis分页插件PageHelper手写实现示例
这篇文章主要为大家介绍了Mybatis分页插件PageHelper手写实现示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-08-08
关于junit测试需要的依赖
这篇文章主要介绍了关于junit测试需要的依赖，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-12-12