Java8之Supplier、BinaryOperator

今天我学习了Java8的新的函数式接口—Supplier、BinaryOperator;接下来，我们来一个一个的分析它们的源码。

Supplier 源码分析

顾名思义，Supplier的意思是供应商、提供者的意思。

// 其中官方文档的意思是：
// 1.每次调用Supplier的时候不要求返回新的或者不同的值；
// 2.T 泛型代表的是 该供应商提供的结果类型，也是说他是不接收参数，
// 并返回值的
@FunctionalInterface
public interface Supplier<T>

下面看一下它的方法
源码：

// 不接收参数，返回一个值
T get();

示例分析：

public class Student {
    private String name ="liqin";
    private int age = 20;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

	// lambda表达式方法
	// 调用一个无参构造方法
	Supplier<Student> supplier = () -> new Student();
	System.out.println(supplier.get().getName());
	// supplier函数式接口不接受参数，返回一个结果
	// 方法引用方法
	Supplier<Student> supplier2 = Student::new;
	System.out.println(supplier2.get().getName());

这里有两种写法，第一种：是lambda表达式的写法；第二种是方法引用的写法。

lambda表达式的写法

因为函数式接口Supplier是一个不接收参数，返回一个值。所以lambda表达式的前半部分就应该是（）的写法，那么为什么要在后面写 new Stundent(),
因为他需要实例出这个对象（并且必须是无参构造），才可以调用里面的getName（）方法。而且我还发现了。

// Supplier<Student> supplier = () -> new Student();
// System.out.println(supplier.get().getName());
// 当你使用getName()方法时，编译器会自动提示你使用这种写法
public Student() {
        name = "liqin";
    }

方法引用不讲解，后面的文章我会讲解的
这就是Supplier 接口，感觉是不是很简单，但是它是Java8的四大函数式接口，是非常重要的，如果没看懂我写的，希望大家再去看看其他文章，一定要搞懂。

BinaryOperator 源码分析

打开源码，我并没有发现他有自己的抽象方法啊，他为什么也是函数式接口呢，仔细一看，因为他继承了BiFunction，也就是继承了apply（）方法。那么他有什么特殊的呢？我们来了解一下。

// 简单地说：BinaryOperator是BiFunction 的一个特例，
// 即：BinaryOperator也接收三个参数，但是函数的参数和返回值是相同类型的，
// 所以，自定义了一个泛型 T。
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T>

那么接下来我们来分析一下BinaryOperator中抽象方法。

第一个方法 ----- apply 方法

源码：

// 等用于BiFunction中的apply方法 
R apply(T t, U u);

示例代码：

// 计算两个数的加减法，我觉得是对BinaryOperator接口的最好示例了，
// 之前也是使用过BiFunction实现，但是需要三个接口。
// 而BinaryOperator只需要定义一个类型就可以了，比较方便。
BinaryOperatorTest binaryOperatorTest = new BinaryOperatorTest();
System.out.println(binaryOperatorTest.add(1, 2, (a, b) -> a + b));
public Integer add(int a, int b, 
BinaryOperator<Integer> binaryOperator) {
        return binaryOperator.apply(a, b);
    }

第二个方法 ----- minBy（静态方法）

源码：

// 返回一个BinaryOperator对象,根据指定的比较规则（比较器）,
// 用来返回两个元素最小的那一个。
public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

示例代码：

// 输出结果：world
// minBy返回的是BinaryOperator对象，调用apply方法将两个参数传进去
// 进行比较，按比较规则输出。
BinaryOperatorTest binaryOperatorTest = new BinaryOperatorTest();
System.out.println(binaryOperatorTest.getShort("hello123", "world", (a, b) -> a.length() - b.length()));


	public String getShort(String a, String b, Comparator<String> comparator) {
        return BinaryOperator.minBy(comparator).apply(a, b);
    }

BinaryOperator还有一个静态方法----maxBy，跟minBy是相反的，搞懂了minBy，也就搞懂了maxBy，我也就不做讲解了。
maxBy源码

// 值得注意的是，comparator.compare(a, b) >= 0 ? a : b;
// 与minBy判断相反，其他地方都一样。
 public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }