Java8函数式编程接口:ConsumerSupplierFunctionPredicate

Posted 苍山有雪,剑有霜

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java8函数式编程接口:ConsumerSupplierFunctionPredicate相关的知识,希望对你有一定的参考价值。

开宗明义

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

以上是关于Java8函数式编程接口:ConsumerSupplierFunctionPredicate的主要内容,如果未能解决你的问题,请参考以下文章

Java8:函数式编程Stream

Java8的函数式编程怎么样?

初识函数式编程与函数式接口

Java8函数式编程接口:ConsumerSupplierFunctionPredicate

[一] java8 函数式编程入门 什么是函数式编程 函数接口概念 流和收集器基本概念

Java8函数式编程:Lambda表达式类型与常用函数接口