开宗明义

java8的一个新特性就是在java.util.function中提供了四个函数式编程接口，分别是Consumer、Supplier、Function、Predicate。

其中，

• consumer即消费接口，传入一个参数，并对其进行相应的操作（有点类似于lambda表达式）；

• supplier即供给接口，可以传入数据，作为一个容器；

• function即方法接口，主要是用作数据类型之间的转换；

• predicate即判断接口，传入参数，而后返回判断的结果true/false；

接下来仔细瞅瞅这四种接口的源码以及怎么使用它们。

庖丁解牛

consumer

源码

Consumer接口的源码只有两个方法，一个方法用来接收入口参数，另外一个是为了实现流式操作：

@FunctionalInterface
public interface Consumer<T> {

    /**
     *接收一个泛型入参
     */
    void accept(T t);

    /**
     * 是指在进行这个consumer之后，在将结果送进另外一个consumer，
		 * 从而实现consumer的流式操作(一个接一个地进行)
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

注：@FunctionalInterface注解即是表明它是一个函数接口，另外的supplier、function、predicate同样如此。

示例

实现Consumer接口可以有三种方式，看下面：

public static void main(String[] args) {
        //1：平平无奇：直接创建接口并重载
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        Stream<String> stream1 = Stream.of("spring", "summer", "autumn", "winter");
        stream1.forEach(consumer1);
        System.out.println("********************");

        //2：偶有起色： 使用Java8另外一个特性，方法引用
        Consumer consumer2 = System.out::println;
        Stream<String> stream2 = Stream.of("spring", "summer", "autumn", "winter");
        stream2.forEach(consumer2);
        System.out.println("********************");

        //3：精彩绝伦，使用lambda表达式
        Consumer<String> consumer3 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口
        Stream<String> stream3 = Stream.of("spring", "summer", "autumn", "winter");
        stream3.forEach(consumer3);
    }
//改写自：https://cloud.tencent.com/developer/article/1488128

结果如下：

spring
summer
autumn
winter
********************
spring
summer
autumn
winter
********************
spring
summer
autumn
winter

注：Stream只能用一次，无法reuse，违规则报错，因此在上述测试的时候建立了多个Stream对象；

注：方法引用和lambda表达式就是consumer的实现，所以不用显示调用accept。

另外，对于集合类的foreach，是因为那么都实现了iterable接口，并且itrable接口支持Consumer：

public interface Iterable<T> {
    //forEach方法传入的就是Consumer
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
}

Supplier

源码

Supplier可以简单的视为就是一个存放指定类型的容器，需要时再取出来：

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

在Optional类的orElseGet、orElse等API就使用了类Supplier,其中orElseGet的源码如下：

Optional.orElseGet(Supplier<? extends T>) 

示例

和上面的Consumer一样，Supplier也可以通过三种方式来使用：

public void test_Supplier() {
        //1: 直接新建一个Supplier接口
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                //返回一个随机值
                return new Random().nextInt();
            }
        };
        System.out.println(supplier.get());
        System.out.println("********************");

				//2： 使用方法引用
        Supplier<Double> supplier2 = Math::random;
        System.out.println(supplier2.get());
				System.out.println("********************");

        //3： 使用lambda表达式
        supplier = () -> new Random().nextInt();
        System.out.println(supplier.get());
    }
//改写自：https://cloud.tencent.com/developer/article/1488128

结果如下：

-1704173567
********************
0.7995174190529915
********************
2009273688

Process finished with exit code 0

可知，Suppiler就是一个用来获取对应类型返回值的函数接口，返回值可以通过传入的参数来设定。

Function

源码

Function的抽象方法只有一个apply，即对传入的参数进行处理并返回，其他的都是辅助方法：

@FunctionalInterface
public interface Function<T, R> {   
 		/**
  	* 抽象方法: 对一个数据类型T加工得到另一个数据类型R
  	*/
		R apply(T t);

  	/**
  	* 组合函数，调用当前function之前调用
 	 	*/
  	default <V> java.util.function.Function<V, R> compose(java.util
		.function.Function<? super V, ? extends T> before) {
  	Objects.requireNonNull(before);
  		return (V v) -> apply(before.apply(v));
 		 }

    /**
    * 组合函数，调用当前function之后调用
    */
  	default <V> java.util.function.Function<T, V> andThen(java.util
		.function.Function<? super R, ? extends V> after) {
  	Objects.requireNonNull(after);
  		return (T t) -> after.apply(apply(t));
  	}

  	/**
  	*  静态方法，返回与原函数参数一致的结果。x=y
  	*/
  	static <T> java.util.function.Function<T, T> identity() {
  		return t -> t;
  	}
  }

示例

Function接口的示例可以通过这个例子来一窥究竟：

public static void main(String[] args) {
        applyTest();
        andThenTest();
        composeTest();
        test();
    }

    //1、apply 示例
    private static void applyTest() {
        //示例1：利用lambda方式实现一个funciton,将String转换为Integer
        Function<String, Integer> function = x -> Integer.parseInt(x);
        Integer a = function.apply("100");
        System.out.println(a.getClass());
    }

    //2、andThen 示例——实现一个函数 y=10x + 10;
    private static void andThenTest() {
        //先执行 10 * x
        Function<Integer, Integer> function2 = x -> 10 * x;
        //通过andThen在执行 这里的x就等于上面的10 * x的值
        function2 = function2.andThen(x -> x + 10);
        System.out.println(function2.apply(2));
    }

    //3、compose 示例-实现一个函数 y=(10+x)2
    private static void composeTest() {
        Function<Integer, Integer> function3 = x -> x * 2;
        //先执行 x+10 在执行(x+10)*2顺序与上面相反
        function3 = function3.compose(x -> x + 10);
        System.out.println(function3.apply(3));
    }

    //4、综合示例
		//使用compose()、andThen()实现一个函数 y=(10+x)*2+10;
    private static void test() {
      //真正执行的第二步
      Function<Integer, Integer> function4 = x -> x * 2;
      //真正执行的第一步
      function4 = function4.compose(x -> x + 10);
      //真正执行的第三步
      function4 = function4.andThen(x -> x + 10);
      System.out.println(function4.apply(3));
    }

先自己想一想结果，再往下看！！

输出结果为：

class java.lang.Integer
30
26
36

Process finished with exit code 0

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

Function 接口实现 apply 方法来做转换。

Predicate

源码

Predicate的源码如下，该方法的辅助方法较多：

public interface Predicate<T> {
    /**
     * 判断参数T是否满足要求,可以理解为 条件A
     */
    boolean test(T t);
    /**
     * 调用当前Predicate的test方法之后再去调用other的test方法,相当于进行两次判断
     * 可理解为 条件A && 条件B
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    /**
     * 对当前判断进行"!"操作,即取非操作，可理解为 ! 条件A
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    /**
     * 对当前判断进行"||"操作,即取或操作,可以理解为 条件A ||条件B
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * 对当前操作进行"="操作,即取等操作,可以理解为 A == B
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}
//源码来自：https://www.cnblogs.com/qdhxhz/p/12050701.html

示例

这里给出两种实现Predicate接口的方式——直接创建与lambda表达式：

public class TestFunction {
    public static void main(String[] args) {
            //1：直接创建Predicate接口
            Predicate<Integer> predicate = new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) {
                    if(integer > 10){
                        return true;
                    }
                    return false;
                }
            };

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

            //2： 通过lambda表达式，
            predicate = (t) -> t > 5;
            System.out.println(predicate.test(1));
            System.out.println("********************");

        }
    }
//改写自：https://cloud.tencent.com/developer/article/1488128

结果为：

false
********************
false
********************

Process finished with exit code 0

总结

看了以上四个函数式接口的源码、示例，也许会有点疑惑——这些东西到底有啥用？感觉用处不大啊！

回答：为了进行函数式编程。关于函数式编程的好处和理念之后再细说，详情可参考。

参考资料

https://cloud.tencent.com/developer/article/1488128

https://www.cnblogs.com/qdhxhz/p/12050701.html

https://www.cnblogs.com/qdhxhz/p/11323595.html