函数式接口

// 定义一个布尔表达式
@FunctionalInterface
public interface Predicate<T> {
  boolean test(T t)
}

// 接受两个对象，返回boolean
BiPredicate<L,R> {
  (L, R) -> boolean
}

// 访问T类型的对象，执行某些操作，但不返回。
@FunctionalInterface
public interface Consumer<T> {
  void accept(T t);
}

// 访问T类型对象和R类型对象
BiConsumer<T, U> {
  (T, U) -> void
}

// 接受输入T类型对象，映射输出R类型对象
@FunctionalInterface
public interface Function<T, R> {
  R apply(T t)
}

// T和U两个类型，映射成一个类型R

BiFunction<T, U, R> {
  (T, U) -> R
}

// 类似工厂方法，不接受外部参数，制造一个T对象
Supplier<T> {
  () -> T
}

// 一元操作符，进来T，出去也是T
UnaryOperator<T> {
  T -> T
}

// 二元操作符
BinaryOperator<T> {
  (T, T) -> T
}

复合Lambda表达式

比较器复合

inventory.sort(comparing(Apple::getWeight).reversed()
  .thenComparing(Apple::getCountry)) // 两个苹果一样重，按国家排序

谓词复合

Predicate<Apple> redAndHeavyAppleOrGreen = 
  redApple.and(a -> a.getWeight > 150)
    .or( a -> "green".equals(a.getColor()));

函数复合

Function<String, String> addHeader = Letter::addHeader;
Function<String, String> transformationPipeline = 
  addHeader.andThen(Letter::checkSpelling)
    .andThen(Letter::addFooter);