大家好,欢迎来到IT知识分享网。
快速理解Consumer、Supplier、Predicate与Function
一、前言
这几个接口都处在java.util.function包下,Consumer(消费型),Supplier(供给型)、Predicate(判断型)与Function(转换型),暂时不理解他们的类型没关系。
如果对Lambda不怎么理解的同学,可以先移步到我的另外一篇文章对Lambda的理解
二、Consumer
Consumer是一个消费型的接口,它接收一个🍉,然后对这个西瓜进行消费,连西瓜籽都不带留下的。
先看Consumer接口的源码,有一个未实现的抽象方法,和一个默认方法(jdk1.8之后,接口里面可以有默认方法和静态方法)。
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
我们只在意这个accept方法,接收一个泛型参数,不返回任何值。ok,我们来简单实现它
Consumer<Integer> consumer=new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
}
};
consumer.accept(1);
}
好了,用脚指头想着,肯定是输出1了。
接下来我们使用lambda表达式来对此匿名内部类进行改写。此时该lambda的类型就是Consumer类型。
consumer=i-> System.out.println(i);
当然我们也可以使用方法引用
consumer=System.out::println;
在Stream类中,我们发现常用的forEach接口接收一个Consumer类型的参数,源码如下
void forEach(Consumer<? super T> action);
二话不说,我们将consumer传入forEach中,来实现遍历集合的操作。
List<Integer> list= Arrays.asList(1,2,3,4,5);
Consumer<Integer> consumer= System.out::println;
list.stream().forEach(consumer);
将中间consumer对象去掉呢,代码会变得更加简洁。咦,到这里,是不是有一种似曾相识的感觉,原来是这样演变来的。
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.stream().forEach(System.out::println);
Consumer总结:
- Consumer接口是一个消费型的接口,只要实现它的accept方法,就能作为消费者来输出信息。
- lambda、方法引用都可以是一个Consumer类型,因此他们可以作为forEach的参数,用来协助Stream输出信息。
- Consumer还有很多变种,例如IntConsumer、DoubleConsumer与LongConsumer等,归根结底,这些变种其实只是指定了Consumer中的泛型而已,方法上并无变化。
三、Supplier
Supplier是一个供给型的接口,我们可以无条件的从它这里获取东西。
@FunctionalInterface
public interface Supplier<T> {
T get();
}
我们不需要为get方法传入任何参数,就能获得一个结果,这不是白嫖吗?那我想要一个随机数
Supplier<Double> supplier=()->new Random().nextDouble();
//当然也可以使用方法引用
Supplier<Double> supplier1= Math::random;
System.out.println(supplier.get());
下一步,Supplier可以哪些地方呢,毕竟是可以白嫖的,谁不喜欢呢?我们看看Supplier在Optional中的应用。
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}
该方法接收Supplier类型的参数,当Optional内部的value为空时,才会返回Supplier中的值。例如
Optional<Double> optional=Optional.empty();
Supplier<Double> supplier=()->new Random().nextDouble();
optional.orElseGet(supplier);
这必定返回Supplier中的随机值,因为Optional.empty()包含的值就是null。
Supplier总结:
- Supplier是一个供给型的接口,其中的get方法用于返回一个值。
- Supplier也有很多的变种,例如IntSupplier、LongSupplier与BooleanSupplier等
四、Predicate
Predicate是一个判断型接口,看看它的源码。
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
该接口将jdk1.8中接口的变化体现的淋漓尽致,接口不再“纯粹”了,可以有默认方法与静态方法了,下次面试再问道,就得分情况喽,哭出声。
要理解一个接口,我们就去实现它的方法。
Predicate<Integer> predicate=i->i>5;
System.out.println(predicate.test(1));
很明显,输出是false。等等,既然可以进行判断,那和Stream.filter()有没有关系呢?
Stream<T> filter(Predicate<? super T> predicate);
果然是有关系的,啧啧啧,我这敏锐的嗅觉。那我们把Predicate对象传入filter试试?
List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8);
list.stream().filter(i->i>5).forEach(System.out::print);
很简单,输出是678。
Predicate总结:
- Predicate是一个判断型的接口,用一个test方法去测试传入的参数。
- 当然,Predicate也有对应的变种。
五、Function
Function是一个功能型的接口,用于将一种类型的数据转化为另外一种类型的数据。
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
重点关注它的apply方法,现在就去实现它,并将之传入进Stream.map()方法中试试。
public class TestFunction {
static class Student{
String name;
Integer id;
public Student(String name, Integer id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public Integer getId() {
return id;
}
}
public static void main(String[] args) {
List<Student> list= Arrays.asList(new Student("jack",1),new Student("tom",2));
Function<Student,Integer> function= Student::getId;
list.stream().map(function).forEach(System.out::print);
}
}
输出12,可以看得出,Function中的apply方法将Student类型的数据转化为对应id的Integer类型的数据。
Function总结:
- Function是一个转换型的接口,其中的apply可以将一种类型的数据转化成另外一种类型的数据。
- Function的变种就更多了。
六、总结
首先只要记住这四个接口的类型,Consumer(消费型)、Supplier(供给型)、Predicate(判断型)与Function(转换型),
再记住他们对应的抽象方法Consumer(accpet)、Supplier(get)、Predicate(test)与Function(apply)
免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://yundeesoft.com/22244.html