【Java8新特性】04 详解Lambda表达式中Predicate Function Consumer Supplier函数式接口
【Java8新特性】04 详解Lambda表达式中Predicate Function Consumer Supplier函数式接口
数式接口
函数式接口是指只定义了一个抽象方法的接口，不包括default默认方法。
函数式接口的抽象方法的签名称为函数描述符，通过函数描述符可以很好得到Lambda表达式的签名。
常见的函数式接口有：Runnable, Callable, Comparator等。除此之外，Java8设计者还新增了一些比较抽象的函数式接口，比如：Predicate, Consumer, Supplier, Function, UnaryOperator, BinaryOperator等, 这些函数式接口定义在java.util.function包中。
接下来详细介绍function包中定义的抽象接口：
1. Predicate
（1）定义
Predicate是谓词的意思，用来判断泛型T对象是否符合条件，如果符合返回true，否则返回false。
查看jdk源码，定义了一个抽象方法test：
@FunctionalInterface
public interface Predicate<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}
*/
boolean test(T t);
}（2）使用方法
Predicate是一个接口所以不能直接实例化，可以使用匿名类或者Lambda表达式实例化。以Lambda为例：
// 接收string对象，判断是否为空，返回boolean
Predicate predicate = (String str) -> str.isEmpty();下面以一个校验参数的实例说明：
@Test
public void testPredicate() {
String input = "hello java8";
if (validate(input, (str) -> !str.isEmpty() && str.length() > 5)) {
// 校验输入
System.out.println("valid input");
}
}
// 第二个参数接收一个Predicate实例
private <T> boolean validate(T input, Predicate<T> predicate) {
return predicate.test(input);
}（3）函数描述符
Predicate： T -> boolean
接受泛型T对象返回boolean。
注意：java.util.function包中还针对基本类型封装了类似IntPredicate, LongPredicate等接口，这无非是表明只接受Int或Long类型的输入，后面Consumer等函数式接口与这个类似，本文不再赘述。
2. Consumer
（1）定义
Consumer是消费者的意思，用来接收一个泛型T对象，执行相关操作，最后返回void。
查看jdk源码，定义了一个抽象方法accept：
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
}（2）使用方法
使用Lambda表达式实例化Consumer接口：
Consumer<String> consumer = (str) -> System.out.println(str);下面以打印字符串的实例讲解Consumer的用法：
@Test
public void testConsumer() {
String input = "hello java8";
// 打印输入
consume(input, (str) -> System.out.println(str));
}
private <T> void consume(T input, Consumer<T> consumer) {
consumer.accept(input);
}（3）函数描述符
Consumer： T -> void
接受泛型T对象返回void。
3. Supplier
（1）定义
Supplier是提供者的意思，用来生成泛型T对象。
查看jdk源码，定义了一个抽象方法get：
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}（2）使用方法
使用Lambda表达式实例化Supplier接口：
Supplier supplier = () -> "Hello Java8 supplier";下面以获取当前时间的实例讲解Supplier的用法：
@Test
public void testSupplier() {
// 获取当前时间
Long currentTime = supply(() -> System.currentTimeMillis());
}
private <T> T supply(Supplier<T> supplier) {
return supplier.get();
}（3）函数描述符
Supplier： void -> T
接受void返回泛型T对象。
4. Function
（1）定义
Function是函数的意思，用来定义一个抽象函数，接收泛型T对象，返回泛型R对象。
查看jdk源码，定义了一个抽象方法apply：
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
}（2）使用方法
使用Lambda表达式实例化Function接口：
Function<String, Integer> function = (str) -> str.length();下面以判断输入是否以指定字符串开头的实例讲解Function的用法：
@Test
public void testFunction() {
String input = "hello java8";
if(func(input, (String str) -> str.startsWith("hello"))) {
System.out.println("start with hello");
}
}
private <T, R> R func(T t, Function<T, R> function) {
return function.apply(t);
}（3）函数描述符
Function： T -> R
接受泛型T对象，返回泛型R对象。
5. UnaryOperator
（1）定义
UnaryOperator是一元操作符的意思，接收一个泛型T对象参数，返回相同T类型对象。
查看jdk源码，UnaryOperator继承自Function接口，定义了一个identity方法：
@FunctionalInterface
public interface UnaryOperator<T> extends Function<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() {
return t -> t;
}
}（2）使用方法
使用Lambda表达式实例化UnaryOperator接口：
UnaryOperator<Integer> unaryOperator = (Integer i) -> i * i;下面以整数递增的实例讲解UnaryOperator的用法：
@Test
public void testUnaryOperator() {
UnaryOperator<Integer> unaryOperator = (Integer i) -> i * i;
int input = 0;
int result = unaryOperate(input, (Integer i) -> i + 1);
// output: 1
System.out.println(result);
}
private <T> T unaryOperate(T t, UnaryOperator<T> unaryOperator) {
return unaryOperator.apply(t);
}（3）函数描述符
UnaryOperator： T -> T
接受泛型T对象，返回泛型T对象。
6. BinaryOperator
（1）定义
BinaryOperator是二元操作符的意思，接收两个相同泛型参数类型T，返回R类型对象。
查看jdk源码，BinaryOperator继承自BiFunction接口，继承了BiFunction的apply方法：
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<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
*/
R apply(T t, U u);
}（2）使用方法
使用Lambda表达式实例化BinaryOperator接口：
BinaryOperator<String> binaryOperator = (String str1, String str2) -> str1 + str2;下面以整数求和实例讲解BinaryOperator的用法：
@Test
public void testBinaryOperator() {
int a1 = 10;
int a2 = 20;
int sum = binaryOperate(a1, a2, (Integer i1, Integer i2) -> i1 + i2);
// output: 30
System.out.println(sum);
}
private <T> T binaryOperate(T t1, T t2, BinaryOperator<T> binaryOperator) {
return binaryOperator.apply(t1, t2);
}（3）函数描述符
BinaryOperator： (T, T) -> T
接受两个泛型T对象，返回一个泛型T对象。
7. 总结
java.util.function包中定义了很多函数式抽象接口，只要记住它们的函数描述符就可以很方便的知道他们的使用方法。
- Predicate： T -> boolean
- Consumer： T -> void
- Supplier： void -> T
- Function： T -> R
- UnaryOperator： T -> T
- BinaryOperator： (T, T) -> T
— end —