Java中的BinaryOperator和UnaryOperator的简单使用

最近研究了以下java的函数式接口，并简单考虑了一下使用场景，做了一些使用尝试，做一下笔记。
使用BinaryOperator和UnaryOperator构建的方法：

package test;

import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;

public class MethodUtils {
    public static<T> T operator(BinaryOperator<T> binaryOperator, T a, T b) {
        return binaryOperator.apply(a, b);
    }

    public static<T extends Number> List<T> map(UnaryOperator<T> operator, List<T> list) {
        return list.stream().map(t -> operator.apply(t)).collect(Collectors.toList());
    }
}

为了测试功能使用的简单值类：

    public class Value{
        public int val;

        public Value(int val) {this.val = val;}
        public String toString() {return String.valueOf(val);}
    }

使用样例：

 public static void main(String[] args) {
	 //获取两个数之中较大的数
 	System.out.println(MethodUtils.operator(BinaryOperator.maxBy(Comparator.naturalOrder()), 3.4, 5.6));
	System.out.println(MethodUtils.operator(BinaryOperator.maxBy(Comparator.comparingInt((Value v) -> v.val)), new Value(1), new Value(2)));
	//求和
	System.out.println(MethodUtils.operator((a1, a2)-> new Value(a1.val + a2.val), new Value(1), new Value(2)));
	//对一个list里面的每个数执行指定操作得到新的list
	System.out.println(MethodUtils.map(t-> t * t, Arrays.asList(1, 2, 3)));
	System.out.println(MethodUtils.map(t-> t * t, Arrays.asList(1.0, 2.0, 3.0)));
    //使用Number类的操作，里面只有double和int类型
	List<Number> list = new ArrayList<>();
    list.add(3);
    list.add(4.0);

    System.out.println(MethodUtils.map(t->{
        if (t.getClass() == Double.class) {
            return t.doubleValue()*t.doubleValue();
        } else {
            return t.intValue() * t.intValue();
        }
    }, list));
 }

执行结果：

只看operator方法的话，看起来似乎没有太大的用处，但是看map方法的操作感觉就提供了很多方便。

下面的样例演示了一个自定义的MyNumber类的加减乘除操作，该类有两个属性first和second，类型是Number的子类型，加减乘除对first和second分开进行计算(a*b=c=>c.first=a.first*b.first c.second=a.second*b.second)，代码如下：

import java.util.Objects;
import java.util.function.BinaryOperator;

public class MyNumber<T extends Number> {
    private T first;
    private T second;

    public MyNumber (T first, T second) {
        this.first = first;
        this.second = second;
    }

	//这里也可以不取doubleValue，而是根据类型自己进行定义处理，这里为了方便统一取doubleValue进行计算
    public static BinaryOperator<MyNumber> operator(OperatorType type){
        return (a, b) -> new MyNumber(type.operator().apply(a.first.doubleValue() , b.first.doubleValue()), type.operator().apply(a.second.doubleValue() , b.second.doubleValue()));
    }

    public static<V1 extends Number,  V2 extends Number> MyNumber<Double> compute(MyNumber<V1> n1, MyNumber<V2> n2, OperatorType type) {
       return compute(n1, n2, operator(type));
    }

    public static<V1 extends Number,  V2 extends Number> MyNumber<Double> compute(MyNumber<V1> n1, MyNumber<V2> n2, BinaryOperator<MyNumber> operator) {
        Objects.requireNonNull(operator);
        return operator.apply(n1, n2);
    }

    public String toString() {
        return String.format("first: %s, second: %s", first, second);
    }
}

import java.util.function.BinaryOperator;

public enum OperatorType {
    Add(){
        @Override
        public BinaryOperator<Double> operator() {
            return (a, b)-> (a + b);
        }
    },
    Subtract(){
        @Override
        public BinaryOperator<Double> operator() {
            return (a, b)-> (a - b);
        }
    },
    Multiply(){
        @Override
        public BinaryOperator<Double> operator() {
            return (a, b)-> (a * b);
        }
    },
    Divide(){
        @Override
        public BinaryOperator<Double> operator() {
            return (a, b)-> (a / b);
        }
    };
    public abstract BinaryOperator<Double> operator();
}

public static void main(String[] args) {
	MyNumber<Integer> a1 = new MyNumber<>(1, 2);
    MyNumber<Double> a2 = new MyNumber<>(3.0, 5.0);
	System.out.println(MyNumber.compute(a1, a2, OperatorType.Add));
    System.out.println(MyNumber.compute(a1, a2, OperatorType.Subtract));
    System.out.println(MyNumber.compute(a1, a2, OperatorType.Multiply));
    System.out.println(MyNumber.compute(a1, a2, OperatorType.Divide));
}

执行结果：

这个MyNumber样例并没有什么用，只是想研究一下用法，完全没有什么实际用处。