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

interface Supplier<T>

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

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

interface Consumer<T>

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

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

Consumer<Integer> print = x -> System.out.println(x);
//输出10
print.accept(10);

• andThen：调用完consumer自己后，还调用andThen方法参数中指定的Consumer

Consumer<Integer> print = x -> System.out.println(x);
Consumer<Integer> 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<T>

    该接口的中文直译是“断言”，用于返回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

相关资料

Java 8 函数式编程系列

    java8 -函数式编程之Lambda表达式

    java8 -函数式编程之四个基本接口

    java8 -函数式编程之Optional

    java8 -函数式编程之Stream