Java8之Consumer、Supplier、Predicate和Function攻略
今天咱们还讲讲Consumer、Supplier、Predicate、Function这几个接口的用法，在 Java8 的用法当中，这几个接口虽然没有明目张胆的使用，可是，倒是润物细无声的。为何这么说呢？java
这几个接口都在 java.util.function 包下的，分别是Consumer（消费型）、supplier（供给型）、predicate（谓词型）、function（功能性），相信有了后面的解释，你应该很是清楚这个接口的功能了。bash
那么，下面，咱们从具体的应用场景来说讲这个接口的用法！微信
1 Consumer接口
从字面意思上咱们就能够看得出啦，consumer接口就是一个消费型的接口，经过传入参数，而后输出值，就是这么简单，Java8 的一些方法看起来很抽象，其实，只要你理解了就以为很好用，而且很是的简单。app
咱们下面就先看一个例子，而后再来分析这个接口。dom
1.1 Consumer实例
/** * consumer接口测试 */
@Test
public void test_Consumer() {
//① 使用consumer接口实现方法
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
Stream<String> stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
stream.forEach(consumer);
System.out.println("********************");
//② 使用lambda表达式，forEach方法须要的就是一个Consumer接口
stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
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", "ddd", "ccc", "fff");
Consumer consumer2 = System.out::println;
stream.forEach(consumer);
//更直接的方式
//stream.forEach(System.out::println);
}
复制代码
输出结果 ide
1.2 实例分析
① consumer接口分析学习
在代码①中，咱们直接建立 Consumer 接口，而且实现了一个名为 accept 的方法，这个方法就是这个接口的关键了。测试
咱们看一下 accept 方法；这个方法传入一个参数，不返回值。当咱们发现 forEach 须要一个 Consumer 类型的参数的时候，传入以后，就能够输出对应的值了。spa
② lambda 表达式做为 consumer3d
Consumer<String> 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<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());
}
复制代码
输出结果
2.2 实例分析
① 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类型的接口。
2.3 Supplier 实例2
咱们看完第一个实例以后，咱们应该有一个了解了，下面再看一个。
/** * Supplier接口测试2，使用须要Supplier的接口方法 */
@Test
public void test_Supplier2() {
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));
}
复制代码
输出结果
代码分析
Optional<Integer> 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<Integer> supplier = new Supplier<Integer>() {
@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<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));
System.out.println("********************");
}
复制代码
输出结果
3.2 实例分析
① 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));
System.out.println("********************");
复制代码
lambda 表达式返回一个 Predicate 接口，而后调用 test 方法！
3.3 Predicate 接口实例2
/** * Predicate谓词测试，Predicate做为接口使用 */
@Test
public void test_Predicate2() {
//① 将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);
System.out.println("********************");
}
复制代码
输出结果
这段代码，首先建立一个 Predicate 对象，而后实现 test 方法，在 test 方法中作一个判断：若是传入的参数大于 5 ，就返回 true，不然返回 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);
复制代码
这段代码调用 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<String, Integer> function = new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return s.length();//获取每一个字符串的长度，而且返回
}
};
Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccv");
Stream<Integer> stream1 = stream.map(function);
stream1.forEach(System.out::println);
System.out.println("********************");
}
复制代码
输出结果
4.2 代码分析
① Function 接口分析
//① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
Function<String, Integer> function = new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return s.length();//获取每一个字符串的长度，而且返回
}
};
复制代码
这段代码建立了一个 Function 接口对象，实现了一个 apply 方法，这个方法有一个输入参数和一个输出参数。其中，泛型的第一个参数是转换前的类型，第二个是转化后的类型。
在上面的代码中，就是获取字符串的长度，而后将每一个字符串的长度做为返回值返回。
② 重要应用 map 方法
Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccv");
Stream<Integer> 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，获取优质学习资源。
- 1. Java8之Consumer、Supplier、Predicate和Function攻略
- 2. Java8 之Consumer、Supplier、Predicate和Function攻略
- 3. java代码之美（15）---Java8 Function、Consumer、Supplier
- 4. java8 函数式接口——Function/Predict/Supplier/Consumer
- 5. Java Lambda基础——Function, Consumer, Predicate, Supplier, 及FunctionalInterface接口
- 6. Java 8中,Function,Consumer,Predicate,Supplier举例 ,以及CompletableFuture使用
- 7. java.util.function 中的 Function、Predicate、Consumer
- 8. Predicate和Consumer应用
- 9. java8 - 内置函数式接口（Supplier、Function）
- 10. Java8之Predicate函数
- 更多相关文章...
- • SQL MIN() Function - SQL 教程
- • XSLT function-available() 函数 - XSLT 教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • IntelliJ IDEA 代码格式化配置和快捷键
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java8之Consumer、Supplier、Predicate和Function攻略
- 2. Java8 之Consumer、Supplier、Predicate和Function攻略
- 3. java代码之美（15）---Java8 Function、Consumer、Supplier
- 4. java8 函数式接口——Function/Predict/Supplier/Consumer
- 5. Java Lambda基础——Function, Consumer, Predicate, Supplier, 及FunctionalInterface接口
- 6. Java 8中,Function,Consumer,Predicate,Supplier举例 ,以及CompletableFuture使用
- 7. java.util.function 中的 Function、Predicate、Consumer
- 8. Predicate和Consumer应用
- 9. java8 - 内置函数式接口（Supplier、Function）
- 10. Java8之Predicate函数