如果还不懂如何使用 Consumer 接口，来公司我当面给你讲！

当调用accept() 方法的时候就会去调用匿名内部类的方法了，也就是我们传入 getResponse() 的逻辑方法。

Supplier

我们一般称之为“生产者”，没有参数输入，但是能返回结果，为结果的提供者。

@FunctionalInterface
public interface Supplier {

    /**
     *  获取一个结果
     */
    T get();
}

可以举个简单的例子感受下：

Optional optional = Optional.empty();
optional.orElseGet(()->Math.random() );

//orElseGet 方法的源码，里边用到了 get 方法
public T orElseGet(Supplier other) {   
    return value != null ? value : other.get();
}

Function

我把它称为“转换者”，表示接收一个参数通过处理之后返回一个结果的函数。

@FunctionalInterface
public interface Function {

    /**
     *  将 T 类型的参数传入，经过函数表达式的计算，返回 R 类型的结果
     */
    R apply(T t);

    /**
     * 返回一个组合函数，先将参数应用于 before 函数，然后将结果应用于当前函数，返回最终结果。
     * 如果对任一函数的求值引发异常，则会将其转发给组合函数的调用方。
     */
    default  Function compose(Function before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * 返回一个组合函数，先将参数应用与当前函数，然后将结果应用于 after 函数，返回最终的结果。
     * 如果对任一函数的求值引发异常，则会将其转发给组合函数的调用方。 
     */
    default  Function andThen(Function after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     *  返回始终返回其输入参数的函数。
     */
    static  Function identity() {
        return t -> t;
    }
}

我们在 lambda 表达式中应用比较多，所以我们来简单演示下：

@Data
@AllArgsConstructor
public class Teacher {
    private String name;
    private int age;
}

public class TeacherTest {
    public static void main(String[] args) {
       List list = Arrays.asList(
            new Teacher("张三",25),
            new Teacher("李四",28),
            new Teacher("王五",18));
      List collect = list.stream().map(item -> item.getName()).collect(Collectors.toList());
      System.out.println(collect);
    }
}

其中 map 接收的参数就是 Function 类型， item 为传入参数，item.getName() 为返回处理的结果，最后输出结果为

[张三, 李四, 王五]

Predicate 

我们称之为“判断者”，通过接收参数 T 来返回 boolean 的结果。

@FunctionalInterface
public interface Predicate {

    /**
     *  接收一个参数, 判断这个参数是否匹配某种规则, 匹配成功返回true, 匹配失败则返回false
     */
    boolean test(T t);

    /**
     *  接收一个 Predicate 类型的参数，用当前函数和 other 函数逻辑与判断参数 t 是否匹配规则，成功返回true，失败返回 false 
     *  如果当前函数返回 false，则 other 函数不进行计算
     * 在评估 Predicate 期间引发的任何异常都会转发给调用方
     */
    default Predicate and(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     *  返回当前Predicate取反操作之后的Predicate
     */
    default Predicate negate() {
        return (t) -> !test(t);
    }

    /**
     *  接收一个 Predicate 类型的参数，用当前函数和 other 函数 逻辑或 判断参数 t 是否匹配规则，成功返回true，失败返回 false 
     *  如果当前函数返回 true，则 other 函数不进行计算
     * 在评估 Predicate 期间引发的任何异常都会转发给调用方
     */
    default Predicate or(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     *  静态方法：传入一个参数，用来生成一个 Predicate，调用test() 方法时调的 object -> targetRef.equals(object) 函数式
     *
     */
    static  Predicate isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

相信大家在编码过程中经常会遇到该函数式接口，我们举个例子来说一下：

public static void main(String[] args) {
    List list = Arrays.asList(
        new Teacher("张三",25),
        new Teacher("李四",28),
        new Teacher("王五",18));

    list = list.stream().filter(item -> item.getAge()>25).collect(Collectors.toList());
    list.stream().forEach(item->System.out.println(item.getName()));
}

其中 filter() 的参数为 Predicate 类型的，返回结果为：李四

看到这儿，我们常见的四种函数式接口就已经介绍完了。说实话，函数式接口我已经看过好几遍了，尤其是 Consumer 和 Supplier。当时只是脑子里学会了，没有应用到具体的项目中，下次再遇到的时候还是一脸懵逼，不知道大家有没有这种感受。

所以我们需要总结经验教训，一定要将代码的原理搞懂，然后多敲几遍，争取应用到自己的项目中，提升自己的编码能力。

以上就是今天的全部内容了，如果你有不同的意见或者更好的idea，欢迎联系阿Q，添加阿Q可以加入技术交流群参与讨论呦！