Java8 由Oracle在2014年发布，是继Java5之后最具革命性的版本。
Java8吸收其他语言的精髓带来了函数式编程，lambda表达式，Stream流等一系列新特性，学会了这些新特性，可以让你实现高效编码优雅编码。
函数式接口
函数式接口是指只定义了一个抽象方法的接口，不包括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
