vlambda博客
学习文章列表

JDK8(二)常见函数式接口

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,
  1. Supplier
不接受参数,返回一个结果(代表一个供给者)
@FunctionalInterface
public interface Supplier<T> {
  // 函数式方法
  T get();
}

ex:

// lambda
Supplier<String> supplier0 =() -> String.valueOf("a");
//调用
String s = supplier0.get();
// 结果
a
  1. 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");
  1. 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 函数式接口,用于对前面四种的一个扩展,另外为了避免额外的拆装箱性能损耗和使用便捷性,还提供了几种基本数据类型对应的函数式接口。其中有两个是值得注意的:

  1. 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的一元运算
  1. 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执行求和运算


看完三件事

如果你觉得这篇内容对你还蛮有帮助,我想邀请你帮我三个小忙JDK8(二)常见函数式接口JDK8(二)常见函数式接口

  1. 点赞,转发,你们的 『点赞和转发』,才是我创造的动力。

  2. 同时可以期待后续文章ing🚀