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之@ResultMap,@Results,@Result注解的使用
这篇文章主要介绍了Mybatis之@ResultMap,@Results,@Result注解的使用，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-12-12
java多线程编程之为什么要进行数据同步
数据同步就是指在同一时间，只能由一个线程来访问被同步的类变量，当前线程访问完这些变量后，其他线程才能继续访问，下面看一下为什么要进行数据同步
2014-01-01
浅析Java中并发工具类的使用
在JDK的并发包里提供了几个非常有用的并发工具类。CountDownLatch、CyclicBarrier和Semaphore工具类提供了一种并发流程控制的手段，Exchanger工具类提供了在线程间交换数据的一种方法。本文主要介绍了它们的使用，需要的可以参考一下
2022-12-12
java IO流文件的读写具体实例
这篇文章主要介绍了java IO流文件的读写具体实例，有需要的朋友可以参考一下
2013-12-12
Mybatis-plus在项目中的简单应用
Mybatis-plus是Spring框架中OOM的一大利器，其简单易用参考官网文档即可很快上手，本文主要介绍了逻辑删除，自动填充，分页插件等的简单使用，感兴趣的可以了解一下
2021-07-07
Java利用文件输入输出流实现文件夹内所有文件拷贝到另一个文件夹
这篇文章主要介绍了Java实现文件夹内所有文件拷贝到另一个文件夹，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2018-03-03
Java实现MD5加密的四种方式
MD5是一种广泛使用的哈希算法,其输出结果是一个128位的二进制数,通常以32位十六进制数的形式表示,MD5 的底层实现涉及多个复杂的步骤和算法,本文给大家介绍了Java实现MD5加密的四种方式,需要的朋友可以参考下
2025-03-03
Java中包的概念和用法实战案例分析
这篇文章主要介绍了Java中包的概念和用法,结合具体案例形式分析了java包的概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下
2019-09-09
Maven版本冲突的原因分析和解决指南
我们可能会因为Maven功能变更、性能提升、修复漏洞等多种原因,去更换第三方库或框架,此时就容易发生版本冲突,本期我们就介绍一下相关知识,以及如何解决版本冲突方法,需要的朋友可以参考下
2025-11-11
详解maven配置多仓库的方法示例
这篇文章主要介绍了详解maven配置多仓库的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-08-08