场景

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

而java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。

下面介绍四个常用的函数式接口的使用示例。

这四个接口基本满足大部分的使用需求，当然还要其他函数式接口，可根据自己需要查询相关文档。

注：

博客：
霸道流氓气质的博客_CSDN博客-C#,架构之路,SpringBoot领域博主

实现

Supplier<T> 供给型接口，返回值T

Supplier有get()方法，可以返回通用类型的值。

实例化Supplier有如下三种方法

1、通过Supplier接口实现方法，只有一个get方法，无参数，返回一个值

        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return new Random().nextInt();
            }
        };
        System.out.println(supplier.get());

2、通过lambda表达式

    List<Integer> integers = makeList(10, () -> (int) (Math.random() * 10));
    integers.forEach(System.out::println);

    private List<Integer> makeList(int num, Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(supplier.get());
        }
        return list;
    }

3、通过方法引用

        Supplier<Double> supplier1 = Math::random;
        System.out.println(supplier1.get());

Supplier使用示例-求数组最大值

    @Test
    public void test2(){
        //求数组元素最大值
        int[] numbers = {1, 2, 3, 4, 5, 6};
        Integer integer = arrayMax(() -> {
            int max = numbers[0];
            for (int number : numbers) {
                if (max < number) {
                    max = number;
                }
            }
            return max;
        });
        System.out.println(integer);
    }

    private Integer arrayMax(Supplier<Integer> supplier) {
        return supplier.get();
    }

Supplier使用示例-若对象存在则返回，不存在则返回指定值或新建一个对象

        //Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
        Stream<Integer> integerStream = Stream.of(1, 2 );
        Optional<Integer> first = integerStream.filter(integer -> integer > 4).findFirst();
        Supplier<Integer> supplier = ()-> new Random().nextInt();
        //若是first中存在数，就返回这个数，若是不存在，就返回supplier返回的值
        System.out.println(first.orElseGet(supplier));

Consumer<T> 消费型接口，返回值void

Consumer相当于一个放东西的容器，你可以在这个容器里放有一个入参的代码块，然后返回T类型，

当调用accept(T)方法的时候才会去执行容器里的代码。

    @Test
    public void test4(){
        consumer(100,(o -> System.out.println("消费了"+o+"元")));
    }

    private void consumer(Object obj, Consumer<Object> consumer){
        consumer.accept(obj);
    }

Function<T,R>函数型接口，返回值R

    @Test
    public void test5(){
        String str = limitLength("公众号:霸道的程序猿,123456",s -> s.substring(0,10));
        System.out.println(str);
    }

    private String limitLength(String str, Function<String,String> function){
        return function.apply(str);
    }

Predicate<T>断定型接口，返回值boolean

    @Test
    public void test6(){
        boolean isTooLong = isTooLong("霸道的程序猿", (s -> s.length() > 5));
        System.out.println(isTooLong);
    }

    private boolean isTooLong(String str, Predicate<String> predicate){
        return  predicate.test(str);
    }

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/135836.html