【Java8新特性】04 详解Lambda表达式中Predicate Function Consumer Supplier函数式接口

Predicate是谓词的意思，用来判断泛型T对象是否符合条件，如果符合返回true，否则返回false。

查看jdk源码，定义了一个抽象方法test：

@FunctionalInterfacepublicinterfacePredicate<T>{/**

* Evaluates this predicate on the given argument.

* @param t the input argument

* @return {@code true} if the input argument matches the predicate,

* otherwise {@code false}

*/booleantest(T t);}

Predicate是一个接口所以不能直接实例化，可以使用匿名类或者Lambda表达式实例化。以Lambda为例：

// 接收string对象，判断是否为空，返回booleanPredicate predicate=(String str)->str.isEmpty();

下面以一个校验参数的实例说明：

@TestpublicvoidtestPredicate(){String input="hello java8";if(validate(input,(str)->!str.isEmpty()&&str.length()>5)){// 校验输入System.out.println("valid input");}}// 第二个参数接收一个Predicate实例private<T>booleanvalidate(T input,Predicate<T>predicate){returnpredicate.test(input);}

Predicate： T -> boolean

接受泛型T对象返回boolean。

注意：java.util.function包中还针对基本类型封装了类似IntPredicate, LongPredicate等接口，这无非是表明只接受Int或Long类型的输入，后面Consumer等函数式接口与这个类似，本文不再赘述。

2. Consumer

Consumer是消费者的意思，用来接收一个泛型T对象，执行相关操作，最后返回void。

查看jdk源码，定义了一个抽象方法accept：

@FunctionalInterfacepublicinterfaceConsumer<T>{/**

* Performs this operation on the given argument.

* @param t the input argument

*/voidaccept(T t);}

使用Lambda表达式实例化Consumer接口：

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

下面以打印字符串的实例讲解Consumer的用法：

@TestpublicvoidtestConsumer(){String input="hello java8";// 打印输入consume(input,(str)->System.out.println(str));}private<T>voidconsume(T input,Consumer<T>consumer){consumer.accept(input);}

Consumer： T -> void

接受泛型T对象返回void。

3. Supplier

Supplier是提供者的意思，用来生成泛型T对象。

查看jdk源码，定义了一个抽象方法get：

@FunctionalInterfacepublicinterfaceSupplier<T>{/**

* Gets a result.

* @return a result

*/Tget();}

使用Lambda表达式实例化Supplier接口：

Supplier supplier=()->"Hello Java8 supplier";

下面以获取当前时间的实例讲解Supplier的用法：

@TestpublicvoidtestSupplier(){// 获取当前时间Long currentTime=supply(()->System.currentTimeMillis());}private<T>Tsupply(Supplier<T>supplier){returnsupplier.get();}

Supplier： void -> T

接受void返回泛型T对象。

4. Function

Function是函数的意思，用来定义一个抽象函数，接收泛型T对象，返回泛型R对象。

查看jdk源码，定义了一个抽象方法apply：

@FunctionalInterfacepublicinterfaceFunction<T,R>{/**

* Applies this function to the given argument.

* @param t the function argument

* @return the function result

*/Rapply(T t);}

使用Lambda表达式实例化Function接口：

Function<String,Integer>function=(str)->str.length();

下面以判断输入是否以指定字符串开头的实例讲解Function的用法：

@TestpublicvoidtestFunction(){String input="hello java8";if(func(input,(String str)->str.startsWith("hello"))){System.out.println("start with hello");}}private<T,R>Rfunc(T t,Function<T,R>function){returnfunction.apply(t);}

Function： T -> R

接受泛型T对象，返回泛型R对象。

5. UnaryOperator

UnaryOperator是一元操作符的意思，接收一个泛型T对象参数，返回相同T类型对象。

查看jdk源码，UnaryOperator继承自Function接口，定义了一个identity方法：

@FunctionalInterfacepublicinterfaceUnaryOperator<T>extendsFunction<T,T>{/**

* Returns a unary operator that always returns its input argument.

* @param <T> the type of the input and output of the operator

* @return a unary operator that always returns its input argument

*/static<T>UnaryOperator<T>identity(){returnt->t;}}

使用Lambda表达式实例化UnaryOperator接口：

UnaryOperator<Integer>unaryOperator=(Integer i)->i*i;

下面以整数递增的实例讲解UnaryOperator的用法：

@TestpublicvoidtestUnaryOperator(){UnaryOperator<Integer>unaryOperator=(Integer i)->i*i;intinput=0;intresult=unaryOperate(input,(Integer i)->i+1);// output: 1System.out.println(result);}private<T>TunaryOperate(T t,UnaryOperator<T>unaryOperator){returnunaryOperator.apply(t);}

UnaryOperator： T -> T

接受泛型T对象，返回泛型T对象。

6. BinaryOperator

BinaryOperator是二元操作符的意思，接收两个相同泛型参数类型T，返回R类型对象。

查看jdk源码，BinaryOperator继承自BiFunction接口，继承了BiFunction的apply方法：

@FunctionalInterfacepublicinterfaceBinaryOperator<T>extendsBiFunction<T,T,T>{/**

* Applies this function to the given arguments.

* @param t the first function argument

* @param u the second function argument

* @return the function result

*/Rapply(T t,U u);}

使用Lambda表达式实例化BinaryOperator接口：

BinaryOperator<String>binaryOperator=(String str1,String str2)->str1+str2;

下面以整数求和实例讲解BinaryOperator的用法：

@TestpublicvoidtestBinaryOperator(){inta1=10;inta2=20;intsum=binaryOperate(a1,a2,(Integer i1,Integer i2)->i1+i2);// output: 30System.out.println(sum);}private<T>TbinaryOperate(T t1,T t2,BinaryOperator<T>binaryOperator){returnbinaryOperator.apply(t1,t2);}