JDK8-2 常见函数式接口

JDK 提供的常见函数式接口

1. Function

接受一个参数，产生一个返回值（代表一个函数）
@FunctionalInterface
public interface Function<T, R> {
  //函数式方法
  R apply(T t);

  // 组合函数，针对输入参数首先应用before函数，然后应用当前函数，如果对任一函数求值时抛出异常，异常会被传递到调用者
  default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
      Objects.requireNonNull(before);
      return (V v) -> apply(before.apply(v));
  }

  // 组合函数，针对输入参数首先应用当前函数，然后应用after函数
  default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
      Objects.requireNonNull(after);
      return (T t) -> after.apply(apply(t));
  }

  // 静态方法，返回一个返回值是输入参数的Function
  static <T> Function<T, T> identity() {
      return t -> t;
  }
}

ex: 生成一个 Funcation 实例

// 匿名函数
Function<String,String> function0 = new Function<String, String>() {
    @Override
    public String apply(String s) {
        return s+",";
    }
};
// lambda
Function<String,String> function1 = (String a) -> a;
Function<String, String> function2 = Function.identity();
// 方法引用
Function<String,String> function3 = String::valueOf;
// 构造方法引用
Function<String,String> function4 = String::new;

//调用：
function0.apply("abc")
//结果
abc,

2. Supplier

不接受参数，返回一个结果（代表一个供给者）
@FunctionalInterface
public interface Supplier<T> {
  // 函数式方法
  T get();
}

ex:

// lambda
Supplier<String> supplier0 =() -> String.valueOf("a");
//调用
String s = supplier0.get();
// 结果
a

3. Consumer

接受一个参数，不返回结果（代表一个消费者）
期待通过方法副作用操作输入参数
@FunctionalInterface
public interface Consumer<T> {
  // 函数式方法
  void accept(T t);

  // 代表一个组合函数，先执行当前函数，再执行after函数，如果执行当前函数抛出异常，不会执行after函数，如果执行after函数抛出异常，则异常会传递给调用者
  default Consumer<T> andThen(Consumer<? super T> after) {
      Objects.requireNonNull(after);
      return (T t) -> { accept(t); after.accept(t); };
  }
}

ex:

Consumer<String> consumer0 = s->{};
// 调用
consumer0.accept("s");

4. Predicate

接受一个参数，返回一个boolean值（谓词，代表判断）
@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);
  }

  // 通过Objects的equals判断两个对象是否equals
  static <T> Predicate<T> isEqual(Object targetRef) {
      return (null == targetRef)
              ? Objects::isNull
              : object -> targetRef.equals(object);
  }
}

ex:

Predicate<Object> a = Predicate.isEqual("a");
//调用
boolean a1 = a.test("b");
//结果
false

除了以上函数式接口外，JDK 还提供了 Bi 函数式接口,用于对前面四种的一个扩展，另外为了避免额外的拆装箱性能损耗和使用便捷性，还提供了几种基本数据类型对应的函数式接口。其中有两个是值得注意的：

5. UnaryOperator

代表一元运算，可以看到这是一个Function的子接口，不同之处在于输入类型和返回值类型相同
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

  static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

ex：

UnaryOperator<Integer> unaryOperator = a -> a=a+5;
Integer apply = unaryOperator.apply(1);

这儿代表的一元运算就是 a=a+5，调用时，针对输入的Integer值复制给a，执行+5的一元运算

6. BinaryOperator

代表二元运算，是BiFunction的子接口，两个输入类型和输出类型一致
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
  public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator){
      Objects.requireNonNull(comparator);
      return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
  }

  public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator){
      Objects.requireNonNull(comparator);
      return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
  }
}

ex:

BinaryOperator<Integer> binaryOperator = (a, b) -> a + b;
Integer apply = binaryOperator.apply(1, 2);
这儿代表的二元运算是 a+b ,针对输入的Integer执行求和运算