Java8 java.util.function包解析（Function，Consumer，Predicate，Supplier）

Java8的工具包新增了function包，里面主要包含了Function，Consumer，Predicate，Supplier四种类。
一、Function类
Function类包含四种方法，其中一个抽象方法apply()，两个default方法andThen()和compose()，以及一个静态方法identity()。
实例化Function的时候需要实现其中的apply()方法，apply方法接收一个模板类型作为输入参数，在andThen()和compose()方法里会自动调用apply()方法。

andThen方法接收一个Function类的实例，通过andThen可以将任意多个Function的apply方法调用连接起来，在Java8里的源码如下：

default <V> Function<T, V> andThen(Functionsuper R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
}

测试用例：

Function<String, String> function1 = string -> {
    System.out.println("function1输出了： " + string);
    return string;
};
Function<String, String> function2 = string -> {
    System.out.println("function2输出了： " + string);
    return string;
};
function1.andThen(function2).apply("hello world");

输出结果

function1输出了： hello world
function2输出了： hello world

可以看到调用顺序是先调用funtion1然后调用function2。

compose方法和andThen方法一样接收一个另一个Function作为参数，但是顺序与andThen恰恰相反。
在Java8里的源代码如下：

default <V> Function<V, R> compose(Functionsuper V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}

接下来是测试用例，保持前面的不变，只把最后一句由andThen改成

function1.compose(function2).apply("hello world");

输出结果：

function2输出了： hello world
function1输出了： hello world

可以看到这次先执行了function2之后再执行function1。

identity方法是一个静态方法，作用是返回一个Function对象，返回的对象总是返回它被传入的值。
源代码很简单

static  Function<T, T> identity() {
    return t -> t;
}

二、Consumer类
Consumer类包含两个方法，一个accept方法用来对输入的参数进行自定义操作，因为是个抽象方法，所以需要实例化对象的时候进行Override，另一个andThen方法跟Function的方法一样是一个default方法，已经有内部实现所以不需要用户重写，并且具体功能也跟Function差不多。Consumer的中文意思是消费者，意即通过传递进一个参数来对参数进行操作。
示例代码：

import java.util.function.Consumer;

public class Test {
    public static void main(String[] args) {
        Foo f = new Foo();
        f.foo(new Consumer() {
                @Override
                public void accept(Integer integer) {
                    System.out.println(integer);
            }
        });
    }
}

class Foo {
    private int[] data = new int[10];

    public Foo() {
        for(int i = 0; i < 10; i++) {
            data[i] = i;
        }
    }

    public void foo(Consumer consumer) {
        for(int i : data)
            consumer.accept(i);
    }
}

首先新建一个类，在这个类里有一个int型数组，在构造方法里对数组赋初值，然后又一个foo方法传入一个Consumer对象，对每一个数组项调用consumer对象的accept方法。在main函数里实例化Foo对象并调用foo方法。
输出结果：

0
1
2
3
4
5
6
7
8
9

在上面的代码中，由于Java8引入的lambda表达式，所以其中的

        f.foo(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) {
                    System.out.println(integer);
            }
        });

可以简写成

        f.foo(integer -> System.out.println(integer));

或者进一步简写成

        f.foo(System.out::println);

三、Predicate类
Predicate类包含5个方法，最重要的是test方法，这是一个抽象方法，需要编程者自己去Override，其他的三个default方法里都使用到了这个方法，这三个方法分别是and方法，negate方法和or方法，其中and和or方法与前面两个类的andThen方法类似，这两个方法都接受另一个Predicate对象作为参数，and方法返回这两个对象分别调用test方法之后得到的布尔值的并，相当于predicate1.test() && predicate2.test()，or方法返回这两个对象分别调用test方法之后得到的布尔值的或，相当于predicate1.test() || predicate2.test()。

示例代码：

        Predicate<Integer> predicate1 = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer <= 0;
            }
        };
        Predicate<Integer> predicate2 = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 0;
            }
        };
        System.out.println("and: " + predicate1.and(predicate2).test(1));
        System.out.println("or: " + predicate1.or(predicate2).test(1));
        System.out.println("negate: " + predicate1.negate().test(1));

输出结果：

and: false
or: true
negate: true

同样，可以简化成lambda表达式

        Predicate<Integer> predicate1 = integer -> integer <= 0;
        Predicate<Integer> predicate2 = integer -> integer > 0;

四、Supplier类
supplier的中文意思是提供者，跟Consumer类相反，Supplier类用于提供对象，它只有一个get方法，是一个抽象方法，需要编程者自定义想要返回的对象。
示例代码：

        Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                return new Random().nextInt(100);
            }
        };

        int[] ints = new int[10];
        for(int i = 0; i < 10; i++) {
            ints[i] = supplier.get();
        }
        Arrays.stream(ints).forEach(System.out::println);

首先自定义了一个Supplier对象，对于其get方法，我每次都返回一个100以内的随机数，并在之后利用这个对象给一个长度为10的int数组赋值并输出。

输出结果：

49
27
14
46
8
97
20
82
75
30

总结：
util里的function包里并不仅仅只有这四个类，只是其中绝大部分都是由这四种衍生而来的，这个包主要是用于实现Java8最大的特性函数式编程，所以在很多其他的包的一些类中的很多地方都用到了这个function包里的类，更多的情况是作为方法中的一个匿名对象参数来使用，配合简洁的lambda表达式使得程序可读性变得更好。
最近正在学习Java的API，看到网上跟function包相关的知识比较少，所以自己通过了一天的尝试了之后记录总结了一下，肯定还有很多错误，毕竟接触Java的时间不长，以后还会回来修改完善。