Java8之Consumer、Supplier、Predicate和Function攻略

pepperwang 发布于2019-08-19 10:17 / 3102人阅读

摘要：接口有一个方法，可以返回值。在上面的代码中，就是获取字符串的长度，然后将每个字符串的长度作为返回值返回。

今天我们还讲讲Consumer、Supplier、Predicate、Function这几个接口的用法，在 Java8 的用法当中，这几个接口虽然没有明目张胆的使用，但是，却是润物细无声的。为什么这么说呢？

这几个接口都在 java.util.function 包下的，分别是Consumer（消费型）、supplier（供给型）、predicate（谓词型）、function（功能性），相信有了后面的解释，你应该非常清楚这个接口的功能了。

那么，下面，我们从具体的应用场景来讲讲这个接口的用法！

1 Consumer接口

从字面意思上我们就可以看得出啦，consumer接口就是一个消费型的接口，通过传入参数，然后输出值，就是这么简单，Java8 的一些方法看起来很抽象，其实，只要你理解了就觉得很好用，并且非常的简单。

我们下面就先看一个例子，然后再来分析这个接口。

1.1 Consumer实例

/**
     * consumer接口测试
     */
    @Test
    public void test_Consumer() {
        //① 使用consumer接口实现方法
        Consumer consumer = new Consumer() {

            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        Stream stream = Stream.of("aaa", "bbb", "ffffd", "ccc", "fff");
        stream.forEach(consumer);

        System.out.println("********************");

        //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口
        stream = Stream.of("aaa", "bbb", "ffffd", "ccc", "fff");
        Consumer consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口
        stream.forEach(consumer1);
        //更直接的方式
        //stream.forEach((s) -> System.out.println(s));
        System.out.println("********************");

        //③ 使用方法引用，方法引用也是一个consumer
        stream = Stream.of("aaa", "bbb", "ffffd", "ccc", "fff");
        Consumer consumer2 = System.out::println;
        stream.forEach(consumer);
        //更直接的方式
        //stream.forEach(System.out::println);
    }

输出结果

1.2 实例分析

① consumer接口分析

在代码①中，我们直接创建 Consumer 接口，并且实现了一个名为 accept 的方法，这个方法就是这个接口的关键了。

我们看一下 accept 方法；这个方法传入一个参数，不返回值。当我们发现 forEach 需要一个 Consumer 类型的参数的时候，传入之后，就可以输出对应的值了。

② lambda 表达式作为 consumer

Consumer consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口

在上面的代码中，我们使用下面的 lambda 表达式作为 Consumer 。仔细的看一下你会发现，lambda 表达式返回值就是一个 Consumer ；所以，你也就能够理解为什么 forEach 方法可以使用 lamdda 表达式作为参数了吧。

③ 方法引用作为 consumer

Consumer consumer2 = System.out::println;

在上面的代码中，我们用了一个方法引用的方式作为一个 Consumer ，同时也可以传给 forEach 方法。

1.3 其他 Consumer 接口

除了上面使用的 Consumer 接口，还可以使用下面这些 Consumer 接口。
IntConsumer、DoubleConsumer、LongConsumer、BiConsumer，使用方法和上面一样。

1.4 Consumer 总结

看完上面的实例我们可以总结为几点。

① Consumer是一个接口，并且只要实现一个 accept 方法，就可以作为一个“消费者”输出信息。
② 其实，lambda 表达式、方法引用的返回值都是 Consumer 类型，所以，他们能够作为 forEach 方法的参数，并且输出一个值。

2 Supplier 接口

Supplier 接口是一个供给型的接口，其实，说白了就是一个容器，可以用来存储数据，然后可以供其他方法使用的这么一个接口，是不是很明白了，如果还是不明白，看看下面的例子，一定彻底搞懂！

2.1 Supplier实例

**
     * Supplier接口测试，supplier相当一个容器或者变量，可以存储值
     */
    @Test
    public void test_Supplier() {
        //① 使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值
        Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                //返回一个随机值
                return new Random().nextInt();
            }
        };

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

        System.out.println("********************");

        //② 使用lambda表达式，
        supplier = () -> new Random().nextInt();
        System.out.println(supplier.get());
        System.out.println("********************");

        //③ 使用方法引用
        Supplier supplier2 = Math::random;
        System.out.println(supplier2.get());
    }

输出结果

2.2 实例分析

① Supplier接口分析

Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                //返回一个随机值
                return new Random().nextInt();
            }
        };

看一下这段代码，我们通过创建一个 Supplier 对象，实现了一个 get 方法，这个方法无参数，返回一个值；所以，每次使用这个接口的时候都会返回一个值，并且保存在这个接口中，所以说是一个容器。

② lambda表达式作为 Supplier

//② 使用lambda表达式，
        supplier = () -> new Random().nextInt();
        System.out.println(supplier.get());
        System.out.println("********************");

上面的这段代码，我们使用 lambda 表达式返回一个 Supplier类型的接口，然后，我们调用 get 方法就可以获取这个值了。

③ 方法引用作为 Supplier

//③ 使用方法引用
        Supplier supplier2 = Math::random;
        System.out.println(supplier2.get());

方法引用也是返回一个Supplier类型的接口。

2.3 Supplier 实例2

我们看完第一个实例之后，我们应该有一个了解了，下面再看一个。

/**
     * Supplier接口测试2，使用需要Supplier的接口方法
     */
    @Test
    public void test_Supplier2() {
        Stream stream = Stream.of(1, 2, 3, 4, 5);
        //返回一个optional对象
        Optional first = stream.filter(i -> i > 4)
                .findFirst();

        //optional对象有需要Supplier接口的方法
        //orElse，如果first中存在数，就返回这个数，如果不存在，就放回传入的数
        System.out.println(first.orElse(1));
        System.out.println(first.orElse(7));

        System.out.println("********************");

        Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                //返回一个随机值
                return new Random().nextInt();
            }
        };

        //orElseGet，如果first中存在数，就返回这个数，如果不存在，就返回supplier返回的值
        System.out.println(first.orElseGet(supplier));
    }

输出结果

代码分析

Optional first = stream.filter(i -> i > 4)
                .findFirst();

使用这个方法获取到一个 Optional 对象，然后，在 Optional 对象中有 orElse 方法和 orElseGet 是需要一个 Supplier 接口的。

//optional对象有需要Supplier接口的方法
        //orElse，如果first中存在数，就返回这个数，如果不存在，就放回传入的数
        System.out.println(first.orElse(1));
        System.out.println(first.orElse(7));

        System.out.println("********************");

        Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                //返回一个随机值
                return new Random().nextInt();
            }
        };

        //orElseGet，如果first中存在数，就返回这个数，如果不存在，就返回supplier返回的值
        System.out.println(first.orElseGet(supplier));

orElse：如果first中存在数，就返回这个数，如果不存在，就放回传入的数

orElseGet：如果first中存在数，就返回这个数，如果不存在，就返回supplier返回的值

2.4 其他 Supplier 接口

除了上面使用的 Supplier 接口，还可以使用下面这些 Supplier 接口。
IntSupplier 、DoubleSupplier 、LongSupplier 、BooleanSupplier ，使用方法和上面一样。

2.5 Supplier 总结

① Supplier 接口可以理解为一个容器，用于装数据的。
② Supplier 接口有一个 get 方法，可以返回值。

3 Predicate 接口

Predicate 接口是一个谓词型接口，其实，这个就是一个类似于 bool 类型的判断的接口，后面看看就明白了。

3.1 Predicate 实例

/**
     * Predicate谓词测试，谓词其实就是一个判断的作用类似bool的作用
     */
    @Test
    public void test_Predicate() {
        //① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(Integer integer) {
                if(integer > 5){
                    return true;
                }
                return false;
            }
        };

        System.out.println(predicate.test(6));

        System.out.println("********************");

        //② 使用lambda表达式，
        predicate = (t) -> t > 5;
        System.out.println(predicate.test(1));
        System.out.println("********************");

    }

输出结果

3.2 实例分析

① Predicate 接口分析

//① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(Integer integer) {
                if(integer > 5){
                    return true;
                }
                return false;
            }
        };

这段代码中，创建了一个 Predicate 接口对象，其中，实现类 test 方法，需要传入一个参数，并且返回一个 bool 值，所以这个接口作用就是判断！

System.out.println(predicate.test(6));

再看，调用 test 方法，传入一个值，就会返回一个 bool 值。

② 使用lambda表达式作为 predicate

//② 使用lambda表达式，
        predicate = (t) -> t > 5;
        System.out.println(predicate.test(1));
        System.out.println("********************");

lambda 表达式返回一个 Predicate 接口，然后调用 test 方法！

3.3 Predicate 接口实例2

/**
     * Predicate谓词测试，Predicate作为接口使用
     */
    @Test
    public void test_Predicate2() {
        //① 将Predicate作为filter接口，Predicate起到一个判断的作用
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(Integer integer) {
                if(integer > 5){
                    return true;
                }
                return false;
            }
        };

        Stream stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
        List list = stream.filter(predicate).collect(Collectors.toList());
        list.forEach(System.out::println);

        System.out.println("********************");

    }

输出结果

这段代码，首先创建一个 Predicate 对象，然后实现 test 方法，在 test 方法中做一个判断：如果传入的参数大于 5 ，就返回 true，否则返回 false；

Stream stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
        List list = stream.filter(predicate).collect(Collectors.toList());
        list.forEach(System.out::println);

这段代码调用 Stream 的 filter 方法，filter 方法需要的参数就是 Predicate 接口，所以在这里只要大于 5 的数据就会输出。

3.4 Predicate 接口总结

① Predicate 是一个谓词型接口，其实只是起到一个判断作用。
② Predicate 通过实现一个 test 方法做判断。

4 Function 接口

Function 接口是一个功能型接口，它的一个作用就是转换作用，将输入数据转换成另一种形式的输出数据。

4.1 Function 接口实例

/**
     * Function测试，function的作用是转换，将一个值转为另外一个值
     */
    @Test
    public void test_Function() {
        //① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
        Function function = new Function() {
            @Override
            public Integer apply(String s) {
                return s.length();//获取每个字符串的长度，并且返回
            }
        };

        Stream stream = Stream.of("aaa", "bbbbb", "ccccccv");
        Stream stream1 = stream.map(function);
        stream1.forEach(System.out::println);

        System.out.println("********************");

    }

输出结果

4.2 代码分析

① Function 接口分析

//① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
        Function function = new Function() {
            @Override
            public Integer apply(String s) {
                return s.length();//获取每个字符串的长度，并且返回
            }
        };

这段代码创建了一个 Function 接口对象，实现了一个 apply 方法，这个方法有一个输入参数和一个输出参数。其中，泛型的第一个参数是转换前的类型，第二个是转化后的类型。

在上面的代码中，就是获取字符串的长度，然后将每个字符串的长度作为返回值返回。

② 重要应用 map 方法

 Stream stream = Stream.of("aaa", "bbbbb", "ccccccv");
        Stream stream1 = stream.map(function);
        stream1.forEach(System.out::println);

在 Function 接口的重要应用不得不说 Stream 类的 map 方法了，map 方法传入一个 Function 接口，返回一个转换后的 Stream类。

4.3 其他 Function 接口

除了上面使用的 Function 接口，还可以使用下面这些 Function 接口。
IntFunction 、DoubleFunction 、LongFunction 、ToIntFunction 、ToDoubleFunction 、DoubleToIntFunction 等等，使用方法和上面一样。

4.4 Function 接口总结

① Function 接口是一个功能型接口，是一个转换数据的作用。
② Function 接口实现 apply 方法来做转换。

5 总结

通过前面的介绍，已经对Consumer、Supplier、Predicate、Function这几个接口有详细的了解了，其实，这几个接口并不是很难，只是有点抽象，多加理解会发现很简单，并且特别好用！

文章有不当之处，欢迎指正，如果喜欢微信阅读，你也可以关注我的微信公众号：好好学java，获取优质学习资源。

云服务器 GPU云服务器 Supplier Predicate Consumer -consumer-0.9-消费端

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/75761.html

乐字节-Java8新特性之函数式接口

摘要：上一篇小乐带大家学过新特性表达式，什么时候可以使用通常表达式是用在函数式接口上使用的。使用实现创建产生一个工厂对象以上就是小乐带给大家的新特性之函数式接口，下一篇将会为大家带来新特性之方法引用，敬请关注。上一篇小乐带大家学过 Java8新特性-Lambda表达式，什么时候可以使用Lambda？通常Lambda表达式是用在函数式接口上使用的。从Java8开始引入了函数式接口，其说明比较...

lakeside 2019-08-16 16:22 评论0 收藏0
乐字节-Java8核心特性实战之函数式接口

摘要：大家好，上一篇小乐给大家讲述了乐字节核心特性表达式，点击回顾。接下来继续核心特性之函数式接口。感谢大家欣赏小乐带来的核心特性之函数式接口，接下来还会更多核心技术讲解，请关注乐字节如需要视频课程，请搜索乐字节腾讯课堂大家好，上一篇小乐给大家讲述了《乐字节-Java8核心特性-Lambda表达式》，点击回顾。接下来继续：Java8核心特性之函数式接口。什么时候可以使用Lambda？通常...

niceforbear 2019-08-16 17:51 评论0 收藏0
Java8-3-深入理解函数式编程模型

摘要：接下来看下如果使用提供的接口会有哪些改进首先看下接口定义省略该函数式接口唯一的抽象方法接收一个参数，有返回值。是不是有点体验到函数式编程的灵活之处。上一篇文章中，我们总体介绍了创建函数式接口实例的几种方式以及Java8中接口新增的默认方法特性，接下来我们来看下Java8中已经为我们提供的几种典型的函数式接口先看一个示例 public class FunctionTest { ...

longshengwang 2019-08-16 10:54 评论0 收藏0
java8 内置函数（api）总结

摘要：和不同，其没有接收参数。用于剔除重复，与数据库中的用法一致。可以对整型流求最大值，返回。这两个方法是结束操作，只能调用一次。常用的函数接口记录方便以后翻吧接口参数返回类型说明 Predicate T boolean 输入某个值，输出boolean 值，用于对某值进行判定 Consumer T void 输入某值，无输出。用于消费某值 Function T R...

ruicbAndroid 2019-08-16 15:34 评论0 收藏0
Java8特性① Lambda 表达式

摘要：上下文比如接受它传递的方法的参数，或接受它的值的局部变量中表达式需要的类型称为目标类型。但局部变量必须显式声明为，或事实上是。换句话说，表达式只能捕获指派给它们的局部变量一次。注捕获实例变量可以被看作捕获最终局部变量。简介概念 Lambda 表达式可以理解为简洁地表示可传递的匿名函数的一种方式：它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。匿名...

vpants 2019-08-16 10:30 评论0 收藏0