BinaryOperator的使用：

BinaryOperator 是 Java 8 函数式接口，它是 BiFunction 的特例！

核心作用：接收两个同类型参数，处理后返回 同类型 结果。简单理解：两个相同类型的数据运算，返回还是同类型 → 两个入参 + 返回值，三者类型完全一样。

一、先搞懂：它和 BiFunction 的关系

java

运行

// BinaryOperator 源代码（继承自 BiFunction）
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
}

• BiFunction<T, U, R> ：两个参数，返回值（类型可不同）
• BinaryOperator ：两个参数都是 T，返回值也是 T（类型必须相同）
• 核心方法：T apply(T t1, T t2) （和 BiFunction 一样）

一句话区分：

• 要不同类型运算 / 转换 → 用 BiFunction
• 两个同类型运算，返回同类型 → 用 BinaryOperator

二、最基础用法（必看）

1. 匿名内部类（老式）

java

运行

import java.util.function.BinaryOperator;

public class BinaryOperatorTest {
    public static void main(String[] args) {
        // 功能：两个整数相加，返回整数（类型一致）
        BinaryOperator<Integer> add = new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer a, Integer b) {
                return a + b;
            }
        };

        int result = add.apply(10, 20);
        System.out.println(result); // 输出 30
    }
}

2. Lambda 简化（推荐）

java

运行

public class BinaryOperatorTest {
    public static void main(String[] args) {
        // 两个数字相乘（同入同出）
        BinaryOperator<Integer> multiply = (a, b) -> a * b;
        
        int result = multiply.apply(5, 6);
        System.out.println(result); // 30
    }
}

三、常用场景：数值运算、字符串拼接、对象合并

示例 1：字符串拼接

java

运行

// 两个字符串拼接，返回字符串
BinaryOperator<String> concat = (s1, s2) -> s1 + " | " + s2;

String result = concat.apply("Hello", "Java");
System.out.println(result); // Hello | Java

示例 2：数值比较（取最大 / 最小）

自带两个静态方法：

• BinaryOperator.maxBy(Comparator)：取最大值
• BinaryOperator.minBy(Comparator)：取最小值

java

运行

import java.util.Comparator;

public class BinaryOperatorTest {
    public static void main(String[] args) {
        // 取两个数的最大值
        BinaryOperator<Integer> max = BinaryOperator.maxBy(Comparator.naturalOrder());
        System.out.println(max.apply(10, 20)); // 20

        // 取两个数的最小值
        BinaryOperator<Integer> min = BinaryOperator.minBy(Comparator.naturalOrder());
        System.out.println(min.apply(10, 20)); // 10
    }
}

四、实战：Stream 中最常用（reduce 聚合）

Stream.reduce() 方法的参数就是 BinaryOperator！作用：把集合所有数据，两两运算，最终合并成一个结果（求和、求最大、求最小）。

示例：集合求和、求最大值

java

运行

import java.util.Arrays;
import java.util.List;

public class BinaryOperatorTest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        // 1. 求和：1+2+3+4+5
        int sum = list.stream().reduce(0, (a, b) -> a + b);
        // 等价于：reduce(0, Integer::sum);
        System.out.println("总和：" + sum); // 15

        // 2. 求最大值
        int max = list.stream().reduce(Integer::max).get();
        System.out.println("最大值：" + max); // 5
    }
}

五、高级用法：链式调用（andThen）

和 Function / BiFunction 一样，支持 andThen 链式（先执行二元运算，再执行后续操作）。

java

运行

import java.util.function.Function;

public class BinaryOperatorTest {
    public static void main(String[] args) {
        // 第一步：两个数相加
        BinaryOperator<Integer> add = (a, b) -> a + b;
        // 第二步：结果 ×2
        Function<Integer, Integer> doubleNum = x -> x * 2;

        // 先 add，再 double：(10+20)*2 = 60
        var result = add.andThen(doubleNum).apply(10, 20);
        System.out.println(result); // 60
    }
}

六、实战：合并两个对象

java

运行

class User {
    private String name;
    private int age;

    // 构造、get、set、toString
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 合并两个用户：姓名拼接，年龄相加
    public static User merge(User u1, User u2) {
        return new User(u1.getName() + "&" + u2.getName(), u1.getAge() + u2.getAge());
    }

    @Override
    public String toString() { return name + " - " + age; }
}

java

运行

public class BinaryOperatorTest {
    public static void main(String[] args) {
        User u1 = new User("小明", 20);
        User u2 = new User("小红", 18);

        // 合并两个 User，返回 User（同类型）
        BinaryOperator<User> mergeUser = User::merge;
        
        User result = mergeUser.apply(u1, u2);
        System.out.println(result); // 小明&小红 - 38
    }
}

七、终极对比：所有函数式接口（一张表吃透）

表格

八、核心总结

1. BinaryOperator<T>：两个 T 入参，返回 T（三者类型完全一致）
2. 继承自 BiFunction<T, T, T>，是 BiFunction 的简化版
3. 核心方法：apply(T t1, T t2)
4. 最常用场景：Stream.reduce () 聚合（求和、求最大）
5. 自带工具：maxBy()、minBy() 快速取最大 / 最小

一句话记住：两个同类型数据运算，返回同类型，必用 BinaryOperator！