函数式接口Supplier，Consumer，Function，Predicate所有使用方法总结

1. Supplier接口介绍

源码分析

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

一个生产者接口，只有一个get方法，采用注解@FunctionalInterface，可用lambda编程，下面结合Consumer一起举例。

2. Consumer接口介绍

源码分析

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

一个消费者接口，采用accept方法进行消费，Supplier接口方法get无输入，有返回值，Consumer接口方法accept有输入，无返回值，举例如下：

    @Test
    public void test() {
        supplierAndConsumer(()-> {
            int a = 10;
            //可写特定业务逻辑
            return a;
        },(t)->{
            //可写特定业务逻辑
            System.out.println("result：" + t);
        });
    }

    public static void supplierAndConsumer(Supplier<Integer> supplier, Consumer<Integer> consumer) {
        //可写通用业务逻辑
        Integer integer = supplier.get();
        //可写通用业务逻辑
        consumer.accept(integer);
    }
    //输出 result：10

Consumer接口中的andThen方法，适用于分前后消费，举例如下：

    @Test
    public void test() {
        consumerTest("cc", (a) -> System.out.print("11" + a + " "), (b) -> System.out.print("22" + b + " "));
    }

    public static void consumerTest(String s1, Consumer<String> consumer, Consumer<String> consumer1) {
        consumer.andThen(consumer1).accept(s1);
        consumer1.andThen(consumer).accept(s1);
    }
    //输出 11cc 22cc 22cc 11cc

简单分析一下andThen方法，先调用前面的accept，在调用后面的accept；

3. Function接口介绍

源码分析

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

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

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

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

一个类型转换接口，其中apply方法接受一个类型为T的对象，在Function中T在前，表示接受的对象，转换为一个类型为R的对象返回，lambda表达式有输入输出，举例如下：

    @Test
    public void test() {
        int b = 10;
        String trans = trans(b, (c) -> {
            //可进行特定业务逻辑处理
            if (c < 100) {
                return c + "ee";
            } else {
                return c + "ff";
            }
        });
        System.out.println(trans);
    }
    //输出 10ee

    public String trans(Integer a, Function<Integer, String> function) {
        //可进行通用逻辑处理
        return function.apply(a);
    }

特别的，在stream流中，map中只需要Function条件；
andThen方法和compose方法举例如下：

    @Test
    public void test() {
        consumerTest("cc", (a) -> {
            System.out.print("11" + a + " ");
            return "11" + a + " ";
        }, (b) -> {
            System.out.print("22" + b + " ");
            return "22" + b + " ";
        });
    }
    //输出 11cc 2211cc  22cc 1122cc
    
    public static void consumerTest(String s1, Function<String, String> function1, Function<String, String> function2) {
        function1.andThen(function2).apply(s1);
        function1.compose(function2).apply(s1);
    }

andThen方法，接收一个之前的，后面的再接受所有之前的，compose方法，后面的先执行，前面的在后面基础上执行；
最后是identity方法，这个是返回输入，代码示例如下：

    @Test
    public void test() {
        List<Student> list = new ArrayList<>();
        Student student = new Student("5", "66");
        Student student1 = new Student("5", "88");
        list.add(student);
        list.add(student1);
        Map<String, Student> map =  list.stream().collect(Collectors.toMap(Student::getName, Function.identity(), (v1, v2) -> v1));
        System.out.println(map);
        //输出 {5=Student(name=5, age=66)} 如果时v2则是输出{5=Student(name=5, age=88)}
    }

注意在list转map时，要加上(v1, v2) -> v1，否则有两个相同的key会报错java.lang.IllegalStateException: Duplicate key Student(name=5, age=66)；

3.1BiFunction接口介绍

拓展一下BiFunction接口，传入三个对象T，U，R，接收两个对象集合T，U，转换为R对象类型；

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);

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

举例说明：

    @Test
    public void test() {
        Students students = transBiFunction(11, "st", (k, v) -> Students.builder().age(k).name(v).build());
        System.out.println(students);
        //输出 Students(age=11, name=st)
    }

    public Students transBiFunction(Integer i, String s, BiFunction<Integer, String, Students> biFunction) {
        return biFunction.apply(i, s);
    }

其实和Function差不多；

4. Predicate接口介绍

源码分析

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

一个常用来对对象集合过滤的接口，test方法，用于属性判断，接收一个对象，返回布尔值，代码示例如下：

    @Test
    public void test() {
        List<String> list = predicate(Arrays.asList("VCDSNvfdIU", "cdsvv"), (i) -> i.length() < 6);
        System.out.println(list);
    }
    //输出 [cdsvv]

    public List<String> predicate(List<String> list, Predicate<String> predicate) {
        List<String> list1 = new ArrayList<>();
        list.forEach(i -> {
            if (predicate.test(i)) {
                list1.add(i);
            }
        });
        return list1;
    }

推荐下面写法：

    @Test
    public void test() {
        List<String> list = Stream.of("VCDSNvfdIU", "cdsvv").filter(FILTER).collect(Collectors.toList());
        System.out.println(list);
    }

    public static final Predicate<String> FILTER = i -> i.length() < 6;

下面介绍Predicate中and方法和or方法的使用，很好理解不过多解释，代码示例如下：

    @Test
    public void test() {
        List<String> list = Stream.of("VCDSNvfdIU", "cdsvv", "cs").filter(FILTER.and(FILTER1)).collect(Collectors.toList());
        System.out.println(list);
        //输出 [cdsvv]
        List<String> list1 = Stream.of("VCDSNvfdIU", "cdsvv", "cs").filter(FILTER.or(FILTER1)).collect(Collectors.toList());
        System.out.println(list1);
        //输出 [VCDSNvfdIU, cdsvv, cs]
    }

    public static final Predicate<String> FILTER = i -> i.length() < 6;

    public static final Predicate<String> FILTER1 = i -> i.length() > 2;

下面对Predicate中的negate方法和静态方法isEqual进行介绍，代码如下：

    @Test
    public void test() {
        List<String> list = Stream.of("VCDSNvfdIU", "cdsvv", "cs").filter(Predicate.isEqual("cdsvv")).collect(Collectors.toList());
        System.out.println(list);
        //输出 [cdsvv]
        List<String> list1 = Stream.of("VCDSNvfdIU", "cdsvv", "cs").filter(Predicate.isEqual("cdsvv").negate()).collect(Collectors.toList());
        System.out.println(list1);
        //输出 [VCDSNvfdIU, cs]
    }

简单介绍一下，isEqual是一个静态方法，需要接口名+方法名调用，negate其实就是取反。

最近看到一种高级的操作，函数式接口编程在枚举中的应用，分享一下：

public class Test1 {
    @Test
    public void test() {
        System.out.println(transString(55, PRICE));	//输出 55String
        System.out.println(predicateValue(20, PRICE));	//输出 false
    }

    public String transString(Integer a, Cat cat) {
        return cat.getFunction().apply(a);
    }

    public static String transFunction(Integer i) {
        return i + "String";
    }

    public boolean predicateValue(Integer b, Cat cat) {
        return cat.getPredicate().test(b);
    }

    public static boolean transPredicate(Integer i) {
        return i > 100;
    }
}

@Getter
@AllArgsConstructor
public enum Cat {
    PRICE(Test1::transPredicate, Test1::transFunction);
    private final Predicate<Integer> predicate;
    private final Function<Integer, String> function;
}

简单分析一下，在枚举类中引入Function和Predicate，判断、转换条件如果长或者是可以复用可以额外拎出来写(只需要关注输入输出即可)，也可以写在枚举里面；