Java：Consumer、Supplier、Predicate、Function详解

前言

在JDK1.8+的环境中，我们会经常使用到Lambda表达式进行编程，会发现Lambda表达式很多方法都需要用到Consumer、Supplier、Predicate与Function这些接口参数，下面举几个大家熟悉的例子

Consumer

List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
list.forEach(System.out::println);

看一下forEach()方法的参数提示

可以看到，forEach()方法接收的是一个Consumer类型的参数

Supplier

我们来看一下我们常用的Optional对象

@Test
public void test() {
	// 如果getList()方法返回值为null，那么就返回orElseGet()方法的值
    List<String> result = Optional.ofNullable(this.getList(0)).orElseGet(() -> Arrays.asList("lisi", "zhaoliu"));
    System.out.println(result);
}
private List<String> getList(int i) {
    return i == 0 ? null : Arrays.asList("jack", "rose", "zhangsan", "wangwu");
}

我们来看一下orElseGet()这个方法用到了啥参数类型

可以看到，orElseGet()方法使用到了Supplier类型参数

Predicate

来看一下循环中的filter()方法用的啥

List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
// 统计集合中字符长度大于3的元素个数
long count = list.stream().filter(str -> str.length() > 3).count();
System.out.println(count);

从参数提示可以看到，filter()方法中使用的是Predicate类型参数

Function

来看一下循环写法中最常用的map()方法

List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
list.stream().map(name -> "hello: " + name).forEach(System.out::println);

看代码提示，可以发现map()方法中接收的是一个Function类型的参数

可见这些类型我们平时经常会用到，下面我们就来逐一熟悉一下他们

一、Consumer

从上面的例子或者这个单词的含义我们可以猜测，它好像是用来消费参数的，我们看一下源码

@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); };
    }
}

可以看到Consumer是个接口，定义了一个accept()抽象方法和andThen()默认方法，accept()方法是一个有入参没返回值的方法，我们主要关注它，下面我们来实现一下它，看一下它是咋用的

直接new一个Consumer对象，并且实现他的accept()方法，泛形我们就用<String>，代表消费的是一个String类型的参数，new完后，我们得到一个consumer对象，接着我们调用它的accept()方法，传入一个字符串进去，我们直接运行一下这个test()方法，看一下结果是什么

@Test
public void test() {
    Consumer<String> consumer = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("Hello Consumer");
}
// Hello Consumer

可以看到，我们传入的字符串被accept()方法接收到了，并被打印了出来，其实Consumer就是这么简单，传一个参数给它，剩下的就交给它去处理

如果你用的编辑器是IDEA的话，如果你这么写，IDEA会予以优化提示，我们直接让IDEA帮我们优化一下，得到如下优化结果

Consumer<String> consumer = s -> System.out.println(s);

到这一步，发现还可以优化，写法更短更简单

Consumer<String> consumer = System.out::println;

我们来改造一下最上面举的例子，就拿list.forEach()试试

@Test
public void test() {
    Consumer<String> consumer = System.out::println;
	List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
	list.forEach(consumer);
}
// jack, rose, zhangsan, wangwu

发现我们定义的集合参数都被打印出来了，它就是这么玩的，其实我们在日常编码中一般会简写，比如上面的我们可能会简写成

List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
list.forEach(System.out::println);

然后它还有一个andThen()方法，我们举个简单的例子看一下咋用

Consumer<String> c1 = System.out::println;
Consumer<String> c2 = s -> System.out.println(s.length());
List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
// 根据andThen的源码可以看到，它的调用对象必须是个Consumer对象，所以先消费c1，然后再消费c2，从打印结果看，也是先打印c1，然后再到c2打印字符串的长度
list.forEach(c1.andThen(c2));
// jack
// 4
// rose
// 4
// zhangsan
// 8
// wangwu
// 6

举了几个例子后，我们以后再碰到入参是一个Consumer对象时我们就应该知道是咋玩的了

二、Supplier

来看一下定义

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

可以看到它就定义了一个get()方法，没有入参，但是有返回值，从字面意思上理解，它就是个供应商，它有个get方法，要啥东西可以直接找它要，那我们来举个例子，看它咋用的

我们定义一个泛形为Double类型的Supplier对象，实现它的get()方法，get()方法就返回一个随机数

@Test
public void test2() {
    Supplier<Double> supplier = new Supplier<Double>() {
        @Override
        public Double get() {
            return Math.random();
        }
    };
    System.out.println(supplier.get());
}
// 0.4866871295581534

我们打印supplier.get()，发现每调用一次就返回了一个新值，它的基本用法跟我们上面理解的一样，我们要啥参数直接找它要就完事了

看完基本用法，我们来把写法改成我们实际简写的样子，经过IDEA第一步优化，是下面这样的

Supplier<Double> supplier = () -> Math.random();

继续优化

Supplier<Double> supplier = Math::random;

到最后，我们来改造一下最上面举的Optional的例子，来看看它咋用的

@Test
public void test() {
	// 在orElseGet方法中引入Supplier，如果this.getList()的值为null，则返回orElseGet()方法中的随机数
    Double result = Optional.ofNullable(this.getList(0)).orElseGet(Math::random);
    // 或者 Double result = Optional.ofNullable(this.getList(0)).orElse(0);
    System.out.println(result);
    // 0.9467969788190213
}
private Double getList(int i) {
    return i == 0 ? null : 0.01d;
}

看吧，这就是它的用法，下次再遇到了应该知道是咋回事了

三、Predicate

从名字来看它是“谓词”的意思，别搞复杂了，它就是用来判断是true还是false的，从最上面filter的例子中也可以看出来

来看一下源码

@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);
    }
}

有一个抽象方法test()，还有三个默认方法，一个静态方法，我们先看一下test()方法，我们写个简单的实现看一下

首先定义一个泛形为<String>的Predicate对象，实现它的test()方法，test()方法接收的是泛形定义的String类型参数，然后我们返回一个判断结果，true或者false

@Test
public void test2() {
    Predicate<String> predicate = new Predicate<String>()
        @Override
        public boolean test(String s) {
            return s != null && s.length() > 2;
        }
    };
    boolean test = predicate.test("hello 996");
    System.out.println(test);
    // true
}

知道用法，我们来看一下实际中简写是什么样的

Predicate<String> predicate = s -> s != null && s.length() > 2;

结合前言中举的例子，我们来改造试一下

@Test
public void test() {
    List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
    // filter方法中直接传入Predicate定义，list在循环的过程中不断根据Predicate来判断，这个方法就是统计list中字符长度大于4的元素数量
	long count = list.stream().filter(s -> s != null && s.length() > 4).count();
	System.out.println(count);
    // 2
}

其它几个默认方法，我就举个and()方法的用法

Predicate<String> p1 = s -> s != null && s.length() > 2;
Predicate<String> p2 = "jack"::equals;
// 先调用p1看长度是不是大于2，再调用p2，看结果是不是和"jack"匹配，最后看两个结果是不是都为true
boolean result = p1.and(p2).test("jack");
System.out.println(result);
// true

四、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;
    }
}

看泛型有个<T, R>，先不管是啥意思，我们来写个例子看看先

定义一个泛形为<String, Integer>的Function对象，实现它的apply()方法，方法接收的泛形的左边定义的String类型，返回的泛形右边定义的Integer类型

@Test
public void test() {
    Function<String, Integer> function = new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
        	// 返回字符串的长度
            return s.length();
        }
    };
    Integer num = function.apply("Hello 996");
    System.out.println(num);
    // 9
}

其实看到这，我们就明白了<T, R>是什么意思了，T代表转换前的原始类型，R代表要转换成的类型

实际中我们都是简写，经过IEDA优化，代码可以简写如下

Function<String, Integer> function = String::length;
System.out.println(function.apply("Hello 996"));

结合最顶上举的例子，循环中的list.stream().map()就用到了Function，我们来改造一下上面的例子，看一下

List<String> list = Arrays.asList("jack", "rose", "zhangsan", "wangwu");
// 这里map方法接收一个Function类型对象，该对象返回每个元素的长度，最后调用forEach方法挨个打印出来
list.stream().map(String::length).forEach(System.out::println);
// 4, 4, 8, 6

其实在实际使用中一般都会采用上面这种匿名函数的形式，举个最常见的写法

List<UserModel> list= super.getList();
// 将list对象中的UserModel在map方法中转成UserVO对象并收集成新的集合
List<UserVO> transList = list.stream().map(o -> {
    UserVO vo = new UserVO();
    BeanUtils.copyProperties(o, vo);
    return vo;
}).collect(Collectors.toList());

Function接口中还定义了compose()和andThen()两个默认方法，我们举个例子看一下（其实从方法定义来看，compose()方法的入参命名为before，andThen方法的入参命名为after，从字面上也可以理解，就是before是先执行，after是后执行）

Function<Integer, Integer> f = i -> i + 1;
Function<Integer, Integer> g = i -> i * 2;
// compose先执行g -> 1 * 2 = 2，再执行f -> 2 + 1 = 3
System.out.println(f.compose(g).apply(1)); // 3
// andThen先执行f -> 1 + 1 = 2，再执行g -> 2 * 2 = 4
System.out.println(f.andThen(g).apply(1)); // 4

收尾

经过上面的这些例子，如果你动手敲了一遍的话今后再遇到参数是这些类型的应该没啥问题了