Java8内置的4大核心函数式接口Predicate、Consumer、Supplier、Function

1、Predicate（断言型）

Predicate断言型函数式接口，接受一个输入参数，返回一个布尔值结果。通常用于对集合或流中的元素进行条件判断、筛选和过滤操作。Predicate接口定义了一个抽象方法：boolean test(T t);该方法接受一个泛型参数 T 的输入参数，并返回一个布尔值。当输入参数满足某个条件时，test()方法返回 true，否则返回 false。

Predicate还提供了一些默认方法：

and(Predicate<? super T> other)：返回一个组合条件，表示当前条件与另一个条件的逻辑与关系。
or(Predicate<? super T> other)：返回一个组合条件，表示当前条件与另一个条件的逻辑或关系。
negate()：返回当前条件的取反条件。
isEqual(Object targetRef)：返回一个判断对象是否与目标对象相等的条件。

使用Predicate的示例：

java
public class Test {

    public static void main(String[] args) {
        List<Person> person = new ArrayList<>();
        person.add(new Person(1, "zhangsan", 18));
        person.add(new Person(2, "lisi", 19));
        person.add(new Person(3, "wangwu", 20));
        person.add(new Person(4, "zhaoliu", 18));
        person.add(new Person(5, "lisi", 22));

        // 筛选集合中ID为偶数且大于2的元素
        Predicate<Integer> predicate = id -> id % 2 == 0;
        person.stream().filter(x -> predicateIdIsEven(x.getId(), predicate.and(id -> id > 2))).forEach(System.out::println);
        
        // 筛选集合中 age >= 20 的元素
        person.stream().filter(x -> predicateAgeGe20(x.getAge(), age -> age >= 20)).forEach(System.out::println);
    }

    private static boolean predicateIdIsEven(int id, Predicate<Integer> predicate) {
        return predicate.test(id);
    }
    
    private static boolean predicateAgeGe20(int age, Predicate<Integer> predicate) {
        return predicate.test(age);
    }

    static class Person {
        private Integer id;
        private String name;
        private Integer age;

        public Integer getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public Integer getAge() {
            return age;
        }

        public Person(Integer id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "{id: " + id + " name: " + name + " age: " + age + "}";
        }
    }
}

// 输出
{id: 4 name: zhaoliu age: 18}
=====分隔=====
{id: 3 name: wangwu age: 20}
{id: 5 name: lisi age: 22}

2、Consumer（消费型）

Consumer消费型函数式接口，接受单个输入参数并在执行操作后不返回任何结果。通常用于对集合或流中的元素进行遍历、消费或修改操作。Consumer接口定义了一个抽象方法：void accept(T t);该方法接受一个泛型参数 T 的输入参数，并在方法体中执行相应的操作，通常是对输入参数进行处理或消费。 Consumer接口还提供了一些默认方法：

andThen(Consumer<? super T> after)：返回一个组合操作，表示当前操作执行完后再执行另一个操作。使用Consumer的示例：

java
public class Test {

    public static void main(String[] args) {
        List<Person> person = new ArrayList<>();
        person.add(new Person(1, "zhangsan", 18));
        person.add(new Person(2, "lisi", 19));
        person.add(new Person(3, "wangwu", 20));
        person.add(new Person(4, "zhaoliu", 18));
        person.add(new Person(5, "lisi", 22));

        // 遍历打印所有姓名，在小写名字后面打印姓名的大写
        Consumer<String> printConsumer = System.out::println;
        person.forEach(x -> printName(x.getName(), printConsumer.andThen(name -> System.out.println(name.toUpperCase()))));
    }

    private static void printName(String name, Consumer<String> printConsumer) {
        printConsumer.accept(name);
    }


    private static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    static class Person {
        private Integer id;
        private String name;
        private Integer age;

        public Integer getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public Integer getAge() {
            return age;
        }

        public Person(Integer id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "{id: " + id + " name: " + name + " age: " + age + "}";
        }
    }
}

// 输出
zhangsan
ZHANGSAN
lisi
LISI
wangwu
WANGWU
zhaoliu
ZHAOLIU
lisi
LISI

3、Supplier（供给型）

Supplier供给型函数式接口，无参数的函数，它提供一个值或对象的生成器。它通常用于延迟计算或提供默认值的场景。Supplier接口定义了一个抽象方法：T get();该方法没有参数，返回类型为泛型参数 T。在方法体中，可以执行相应的逻辑来生成或提供一个值。使用Supplier的示例：

java
public class Test {

    public static void main(String[] args) {
        List<Person> person = new ArrayList<>();
        person.add(new Person(1, "zhangsan", 18));
        person.add(new Person(2, "lisi", 19));
        person.add(new Person(3, "wangwu", 20));
        person.add(new Person(4, "zhaoliu", 18));
        person.add(new Person(5, "lisi", 22));

        // 生成一个Person对象
        Supplier<Person> genPerson = () -> new Person(1, "zhangsan", 18);
        System.out.println(genPerson.get());

        // 提供默认字符串
        Supplier<String> defaultString = () -> "Default Value";
        System.out.println(defaultString.get());
    }

    static class Person {
        private Integer id;
        private String name;
        private Integer age;

        public Integer getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public Integer getAge() {
            return age;
        }

        public Person(Integer id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "{id: " + id + " name: " + name + " age: " + age + "}";
        }
    }
}

// 输出
{id: 1 name: zhangsan age: 18}
Default Value

4、Function（功能型）

Function功能型函数式接口，接受一个输入参数T，返回一个结果R。通常用于对输入进行转换、映射或计算操作。Function接口定义了一个抽象方法：R apply(T t);该方法接受一个泛型参数 T 的输入参数，并返回一个泛型参数 R 的结果。在方法体中，可以执行相应的逻辑来对输入参数进行转换或计算，并返回结果。 Function接口还提供了一些默认方法：

andThen(Function<? super T, ? extends R> after)：返回一个组合操作，表示当前操作执行完后再执行另一个操作。
compose(Function<? super V, ? extends T> before)：返回一个组合操作，表示先执行另一个操作，再执行当前操作。

java
package java.util.function;
import java.util.Objects;

@FunctionalInterface
public interface Function<T, R> {
    // 接受输入参数，对输入执行所需操作后  返回一个结果。
    R apply(T t);

    // 返回一个 先执行before函数对象apply方法，再执行当前函数对象apply方法的 函数对象。
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
       Objects.requireNonNull(before);
       return (V v) -> apply(before.apply(v));
    }

    // 返回一个 先执行当前函数对象apply方法， 再执行after函数对象apply方法的 函数对象。
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }   

    // 返回一个执行了apply()方法之后只会返回输入参数的函数对象。
    static <T> Function<T, T> identity() {
        return t -> t;
    } 
}

使用Function的示例：

java
public class Test {

    public static void main(String[] args) {
        List<Person> person = new ArrayList<>();
        person.add(new Person(1, "zhangsan", 18));
        person.add(new Person(2, "lisi", 19));
        person.add(new Person(3, "wangwu", 20));
        person.add(new Person(4, "zhaoliu", 18));
        person.add(new Person(5, "lisi", 22));

        // 计算所有人的年龄之和
        Function<List<Person>, Integer> totalFunction = l -> {
            Integer total = 0;
            for (Person p : l) {
                total += p.age;
            }
            return total;
        };
        System.out.println(totalFunction.apply(person));

        // 计算所有人的平均年龄
        Function<Integer, Integer> avgFunction = total -> total / person.size();
        System.out.println(avgFunction.apply(totalFunction.apply(person)));

        // 组合操作：先计算所有人的年龄之和，再计算所有人的平均年龄
        Function<List<Person>, Integer> composedFunction = totalFunction.andThen(avgFunction);
        System.out.println(composedFunction.apply(person));
    }

    static class Person {
        private Integer id;
        private String name;
        private Integer age;

        public Integer getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public Integer getAge() {
            return age;
        }

        public Person(Integer id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "{id: " + id + " name: " + name + " age: " + age + "}";
        }
    }
}

// 输出
97
19
19

目录

1、Predicate（断言型）

2、Consumer（消费型）

3、Supplier（供给型）

4、Function（功能型）