不管lambda表达式还是Stream流式编程，Function、Consumer、Supplier、Predicate 四个接口是一切函数式编程的基础。下面我们详细学习这四个巨头，

interface Supplier

该接口的中文直译是“提供者”，可以理解为定义一个lambda表达式，没有输入参数，返回一个T类型的值。

Supplier<Integer> supplier = () -> 10;
//输出10
System.out.println(supplier.get());

interface Consumer

该接口的中文直译是“消费”，可以理解为定义一个lambda表达式，接收一个T类型的参数，并且没有返回值。

accept ：接收参数，并调用Consumer接口里的方法

Consumer print = x -> System.out.println(x); //输出10 print.accept(10);
andThen：调用完consumer自己后，还调用andThen方法参数中指定的Consumer

Consumer print = x -> System.out.println(x); Consumer printPlusSelf = x -> System.out.println(x + x);

//输出10以及20 print.andThen(printPlusSelf).accept(10);

interface Function<T, R>

该接口的中文直译是“函数”，可以理解为：定义一个lambda表达式，接收一个T类型的参数，返回一个R类型的值。

apply：传入一个T类型的参数，返回一个R类型的值

Function<Integer, Integer> plusSelf = x -> x + x;

//apply System.out.println(plusSelf.apply(10));

compose：accept获取到的参数，先执行compose里面的Function，再执行原Function

    //两个function
    Function<Integer, Integer> plusSelf = x -> {
        System.out.println("plusSelf");
        return x + x;
    };
    Function<Integer, String> toString = x -> {
        System.out.println("toString");
        return String.valueOf(x);
    };

    //输出20，整数10先自加变成20，然后由toString转换成字符串
    String string1 = toString.compose(plusSelf).apply(10);
    System.out.println(string1);

andThen：与compose相反。先执行原Function，在执行andThen里面的Function。

    //两个function
    Function<Integer, Integer> plusSelf = x -> {
        System.out.println("plusSelf");
        return x + x;
    };
    Function<Integer, String> toString = x -> {
        System.out.println("toString");
        return String.valueOf(x);
    };

    //输出20, 先自加，再转换成字符串
    String string2 = plusSelf.andThen(toString).apply(10);
    System.out.println(string2);

interface Predicate

该接口的中文直译是“断言”，用于返回false/true。T是lambda表达式的输入参数类型。

test ：测试test方法中输入参数是否满足接口中定义的lambda表达式

    Predicate<String> test = x -> "test".equals(x);
    Predicate<String> test2 = x -> "test2".equals(x);

    //test
    System.out.println(test.test("test")); //true
    System.out.println(test.test("test_false")); //false

and ：原 Predicate 接口和 and 方法中指定的 Predicate 接口要同时为true，test方法才为true。与逻辑运算符 && 一致。

    Predicate<String> test = x -> "test".equals(x);
    Predicate<String> test2 = x -> "test2".equals(x);

    //and
    System.out.println(test.and(test2).test("test")); //false

negate：对结果取反后再输出

    Predicate<String> test = x -> "test".equals(x);
    Predicate<String> test2 = x -> "test2".equals(x);

    //negate
    System.out.println(test.negate().test("test")); //false

or：原 Predicate 接口和 or 方法中指定的 Predicate 接口只要一个为true，test方法为true。与逻辑运算符 || 一致。

    Predicate<String> test = x -> "test".equals(x);
    Predicate<String> test2 = x -> "test2".equals(x);
    //or
    System.out.println(test.or(test2).test("test")); //false