Java 8的中Consumer、Supplier、Predicate和Function

这几个接口都在java.util.function包下的，分别是Consumer（消费型）、supplier（供给型）、predicate（谓词型）、function（功能性）

Consumer接口

从字面上看，Consumer接口就是一个消费型的接口，通过传入参数，然后输出值，就是这么简单

Consumer实例

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

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

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

    //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口
    stream = Stream.of("aaa", "bbb", "ccc");
    Consumer<String> 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", "ccc");
    Consumer consumer2 = System.out::println;
    stream.forEach(consumer);
    //更直接的方式
    //stream.forEach(System.out::println);
}

输出结果

aaa
bbb
ccc
********************
aaa
bbb
ccc
********************
aaa
bbb
ccc

实例分析

① Consumer接口分析

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

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

② lambda表达式作为Consumer

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

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

③ 方法引用作为Consumer

Consumer consumer2 = System.out::println;

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

其他Consumer接口

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

Consumer 总结

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

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

Supplier 接口

Supplier接口是一个供给型的接口，其实，说白了就是一个容器，可以用来存储数据，然后可以供其他方法使用的这么一个接口。

Supplier实例

**
 * Supplier接口测试，supplier相当一个容器或者变量，可以存储值
 */
@Test
public void testSupplier() {
    //① 使用Supplier接口实现方法，只有一个get方法，无参数，返回一个值
    Supplier<Integer> supplier = new Supplier<Integer>() {
        @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<Double> supplier2 = Math::random;
    System.out.println(supplier2.get());
}

输出结果

-19080692
********************
278389927
********************
0.99785060190326665

实例分析

① Supplier接口分析

Supplier<Integer> supplier = new Supplier<Integer>() {
    @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<Double> supplier2 = Math::random;
System.out.println(supplier2.get());

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

Supplier 实例2

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

/**
 * Supplier接口测试2，使用需要Supplier的接口方法
 */
@Test
public void testSupplier2() {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    //返回一个optional对象
    Optional<Integer> 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<Integer> supplier = new Supplier<Integer>() {
        @Override
        public Integer get() {
            //返回一个随机值
            return new Random().nextInt();
        }
    };

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

输出结果

5
5
********************
5

代码分析

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

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

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

其他 Supplier 接口

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

Supplier 总结

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

Predicate 接口

Predicate接口是一个谓词型接口，其实，这就是一个类似于bool类型的判断接口。

Predicate 实例

/**
 * Predicate谓词测试，谓词其实就是一个判断的作用类似bool的作用
 */
@Test
public void testPredicate() {
    //① 使用Predicate接口实现方法，只有一个test方法，传入一个参数，返回一个bool值
    Predicate<Integer> predicate = new Predicate<Integer>() {
        @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));
}

输出结果

true
********************
false

实例分析

① Predicate接口分析

//① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值
Predicate<Integer> predicate = new Predicate<Integer>() {
    @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));

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

Predicate 接口实例2

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

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

输出结果

23
56
6
6

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

```java
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 的数据就会输出。

Predicate 接口总结

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

Function 接口

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

Function 接口实例

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

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

输出结果

3
5
7

代码分析

① `Function`接口分析

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

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

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

② 重要应用 map 方法

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

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

其他 Function 接口

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

Function 接口总结

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