背景

函数式接口为 lambda 表达式和方法引用提供目标类型。每个函数式接口都有一个抽象方法，称为该函数式接口的函数式方法，lambda 表达式的参数和返回类型与之匹配或适应。

Predicate

谓词是根据其变量的值可能为真或为假的陈述。它可以被认为是一个返回真或假值的函数。

public class PredicateDemo {
    public static void main(String[] args) {
        //1.使用接口
        Predicate<Integer> intePredicate = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer>50;
            }
        };
        System.out.println(intePredicate.test(100));
        System.out.println(intePredicate.test(1));
        //2.使用lambda
        Predicate<Integer> lambdaPredicate = t->t>50;
        System.out.println(lambdaPredicate.test(100));
        System.out.println(lambdaPredicate.test(1));
        //当做过滤器使用
        Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
        List<Integer> list = stream.filter(lambdaPredicate).collect(Collectors.toList());
        list.forEach(System.out::println);
    }
}

Function

函数接口是一个函数接口。它的功能之一是将输入数据转换为另一种形式的输出数据。

public class FunctionDemo {
    public static void main(String[] args) {
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        Stream<String> stream = Stream.of("hello", "sir", "ok");
        Stream<Integer> res = stream.map(function);
        res.forEach(System.out::println);
    }
}

Consumer

从字面上看，我们可以看到消费者接口是一个消费者接口。传入参数，然后输出值。

public class ConsumerDemo {
    public static void main(String[] args) {
        //1.使用接口方式
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("consumer process :"+s);
            }
        };
        Stream<String> stream = Stream.of("aaa", "bbb", "ccc");
        stream.forEach(consumer);
        //2.使用lambda方式
        Consumer<String> lambdaConsumer = (c)-> System.out.println("lambda consumer:"+c);
        Stream<String> fruit = Stream.of("apple", "banana", "unkonw");
        fruit.forEach(lambdaConsumer);
        //3.使用方法引用
        Consumer<String> methodConsumer = System.out::println;
        Stream<String> number = Stream.of("1", "2", "3");
        number.forEach(methodConsumer);
    }
}

Supplier

供应商(Supplier)接口是一个面向供应的接口，其实就是一个容器，可以用来存储数据，然后其他方法也可以使用这样的接口。

public class SupplierDemo {
    public static void main(String[] args) {
        //使用接口实现方法
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return new Random().nextInt();
            }
        };

        System.out.println(supplier.get());

        //使用lambda
        supplier = () -> new Random().nextInt();
        System.out.println(supplier.get());

        //使用方法引用
        Supplier<Double> methodSupplier = Math::random;
        System.out.println(methodSupplier.get());
    }
}