下面来近距离观察一下函数式编程的几个特点：
下面jdk1.8里面对函数式编程的定义。只是一个 FunctionalInterface 接口。特别的简单。
这个函数式接口有几点以下的限制：
Stream的操作是建立在函数式接口的组合之上的。Java8中新增的函数式接口都在java.util.function包下。这些函数式接口可以有多种分类方式。
Function是从T到R的一元映射函数。将参数T传递给一个函数，返回R。即R = Function(T)
Function最常用的应该是 <R> Stream<R> map(Function<? super T, ? extends R> mapper);
比如List<Person> person里面有age，name.... 我传入age，他就会返回age的集合给我。
@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;
}
}
Predicate是一个谓词函数，主要作为一个谓词演算推导真假值存在，返回布尔值的函数。Predicate等价于一个Function的boolean型返回值的子集。
predicate最常用的莫过于 Stream<T> filter(Predicate<? super T> predicate);
比如我要过滤年龄 > 18 的人，我传入age，判断是否为true。为true则保留，false丢弃。
@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);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
Consumer是从T到void的一元函数，接受一个入参但不返回任何结果的操作。
Consumer最常用的肯定是 default void forEach(Consumer<? super T> action) {}
这是一段forEach循环的代码，传入实现的方法，并不返回任何值。只是循环。
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
Lambda 的基本结构为 (arguments) -> body，有如下几种情况：
比如如下代码：
List<Integer> list = new ArrayList<>();
list.stream().filter((x) -> x >= 18)
Stream<T> filter(Predicate<? super T> predicate);
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
比如List里面存个个人的年龄，现在筛选出年龄大于等于18的人。
此时我们就可以用 list.stream().filter((x) -> x >= 18) 这就是一个典型的lambda表达式
(x) -> x >= 18 传给 Predicate 函数式接口。
原理其实是