深入探寻JAVA8 part2：浅谈几个内置的函数式接口
深入探寻JAVA8 part2：浅谈几个内置的函数式接口
前情提要
看此文前，不熟悉函数式编程和Lambda表达式的可以先看一下上文回忆一下。
本文将会简单介绍Java8中内置的一些函数式接口
回顾函数式接口
函数式接口就是只定义一个抽象方法的接口。在JAVA8以前，就有很多符合函数式接口定义的接口。
//比较器
public interface Comparator<T> {
int compare(T o1, T o2);
}
//多线程接口
public interface Runnable{
void run();
}因为JAVA8中还引入了默认方法的概念，所以即使接口中有多个默认方法，只要接口之定义了一个抽象方法，就满足函数式接口的定义。
JAVA8中对这些可以定义为函数式接口的接口加了一个@FuncationalInterface注解。如果一个接口中定义了多个抽象方法，又添加了这个注解，则会在编译时抛出错误提示。
Consumer
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
void accept(T var1);
default Consumer<T> andThen(Consumer<? super T> var1) {
Objects.requireNonNull(var1);
return (var2) -> {
this.accept(var2);
var1.accept(var2);
};
}
}这是JAVA8中对Consumer的定义，该函数式接口可以接收一个T类型的数据，并对该数据进行操作。JDK中一个典型的例子是forEach中对Consumer的使用，下面给出了ArrayList中的forEach源码。
@Override
public void forEach(Consumer<? super E> consumer) {
checkNotNull(consumer);
for (E e : array) {
consumer.accept(e);
}
}forEach的接口定义中传入了一个Consumer接口，并且调用Consumer的accept方法对数组中的每个元素进行处理。加入这是一个String数组，则可以使用如下的方式进行调用
list.forEach((String s) -> System.out::println);在Consumer的接口定义中，还有一个andThen的默认方法，后面会再介绍一下这个默认方法。
因为Consumer这个接口使用了泛型，因此只能使用基础类型的封箱类型，如Integer，Long等。如果是对基础类型的元素进行处理，可能会出现大量的封箱拆箱的操作，造成性能损耗。为了解决这个问题，JAVA也提供了基础类型的对应的Consumer接口，如IntConsumer：
@FunctionalInterface
public interface IntConsumer {
void accept(int value);
default IntConsumer andThen(IntConsumer after) {
Objects.requireNonNull(after);
return (int t) -> { accept(t); after.accept(t); };
}
}Predicate
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}Predicate函数式接口定义了test抽象方法，它会对T对象执行判断逻辑，并返回布尔类型的判断接口。
还是以ArrayList中的一个使用场景为例。ArrayList中提供了一个removeIf方法，该方法传入了Predicate接口，并利用该接口判断是否要删除这个对象：
public boolean removeIf(Predicate<? super E> filter) {
checkNotNull(filter);
E[] newArray = null;
int newIndex = 0;
for (int index = 0; index < array.length; ++index) {
E e = array[index];
//使用Predicate的test方法判断是否要删除该对象
if (filter.test(e)) {
if (newArray == null) {
newArray = ArrayHelper.clone(array, 0, index);
newIndex = index;
}
} else if (newArray != null) {
newArray[newIndex++] = e;
}
}
if (newArray == null) {
return false;
}
array = newArray;
return true;
}当然了，同Consumer一样，它也提供了很多可以传入基础类型的Predicate接口，如IntPredicate，DoublePredicate等
Function
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}Function中定义了apply抽象方法，该抽象方法会接受一个T类型的对象，并转化为R类型的对象返回。使用方法和上面也没啥区别，这里就不具体赘述了。当然了，Function也为基础类型做了很多扩展，比如IntToDoubleFunction就可以将int转化为double型，还有ToDoubleFunction<T>则支持将T对象转化为double基础型。
复合Lambda表达式
复合Lambda表达式是指将多个同类型的Lambda表达式按照一定语法进行组合，生成新的Lambda表达式。以比较基础的Predicate作为例子。Predicate中有以下几个默认方法：and,negate,or，分别对应与，否定和或。
举个例子，现在有两个Predicate分别是判断订单的状态是否为已支付以及订单的实付金额是否大于100。两个Predicate如下：
Predicate<Order> p1 = (Order o) -> o.isPaid;
Predicate<Order> p2 = (Order o) -> o.actualFee > 100;假如现在想要判断是已支付且实付金额大于100的订单，则新的Predicate可以通过上面两个Predicate组合生成，利用and默认方法：
Predicate<Order> p3 = p1.and(p2);腾讯云开发者
