Java8常见函数式接口总结

函数式接口

• 函数式接口：有且仅有一个抽象方法的接口。
• 使用@FunctionalInterface注解来标记。如果接口不是函数式接口就会编译出错
• 满足条件的接口即使不加上注解，那也是函数式接口
• 函数式接口可以作为方法的参数

  public static void main(String[] args) {
          // 1. 匿名类作为参数
          startThread(new Runnable() {
              @Override
              public void run() {
                  System.out.println(Thread.currentThread().getName());
              }
          });
          // 2. 函数式接口作为参数
          startThread(() -> System.out.println(Thread.currentThread().getName()));
      }
  
      public static void startThread(Runnable r){
          new Thread(r).start();
      }
  

• 函数式接口可以作为方法的返回值

  public static void main(String[] args) {
          // 函数式接口作为返回值
          List<String> list = new ArrayList<>();
          list.add("aa");
          list.add("bbbbb");
          list.add("c");
  
          System.out.println(list);
          Collections.sort(list, getComparator());
          System.out.println(list);
      }
  
      public static Comparator<String> getComparator(){
          // 1. 直接新建匿名对象
  //        Comparator<String> comp = new Comparator<String>() {
  //            @Override
  //            public int compare(String o1, String o2) {
  //                return o1.length() - o2.length();
  //            }
  //        };
  //        return comp;
  
          // 2. 使用lambda
          Comparator<String> comp = (o1, o2) -> o1.length() - o2.length();
          return comp;
      }
  

常用的函数式接口

• Supplier<T>: 没有输入，返回一个T类型的结果。
• Consumer<T>: 输入一个 T 类型参数，没有返回值。
• Predicate<T>: 输入一个T类型参数，返回boolean。
• Function<T, R> : 输入一个T类型参数，返回R类型参数。

对应的还有两个参数的版本：

• BiConsumer<T, U>: 输入是 T 和 U 类型的数据，无返回值
• BiPredicate<T, U>: 输入是 T 和 U 类型的数据，返回 boolean 类型。
• BiFunction<T, U, R>： 输入是 T 和 U 类型的数据，返回 R 类型。

Function<T, R> 接口

@FunctionalInterface
public interface Function<T, R> {

    // 输入T类型参数，输出R类型结果
    R apply(T t);

    // 返回一个新的Function。先执行before，再执行当前
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    // 返回一个新的Function。限制性当前，再执行after
    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<String, String> func1 = (x) -> x + "1";
    Function<String, String> func2 = (x) -> x + "2";

    System.out.println(func1.apply("0"));                   // 01
    System.out.println(func1.andThen(func2).apply("0"));    // 012
    System.out.println(func1.compose(func2).apply("0"));    // 021

Consumer<T> 接口

@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); };
    }
}

    Consumer<StringBuilder> consumer = (x) -> {
        x.append("1");
    };
    StringBuilder str = new StringBuilder("0");
    consumer.accept(str);
    System.out.println(str.toString());         // 01

Supplier<T> 接口

@FunctionalInterface
public interface Supplier<T> {

    // 获取一个元素
    T get();
}

lambda可捕获局部变量

    // Suplier
    Supplier<String> supplier = () -> "aaa";
    System.out.println(supplier.get());

    // 使用外部变量
    int arr [] = {20, 40, 30, 10};
    Supplier<Integer> getMax = ()-> {
        int max_ = arr[0];
        for (int item : arr){
            if (item > max_)    max_ = item;
        }
        return max_;
    };
    System.out.println(getMax.get());

Predicate<T> 接口

@FunctionalInterface
public interface Predicate<T> {

    // 输入一个t，返回boolean
    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);
    }
}

    // Predicate
    Predicate<String> predicate = (x)-> x.contains("0");
    Predicate<String> predicate2 = (x) -> x.contains("1");

    System.out.println(predicate.test("0123"));                     // true
    System.out.println(predicate.negate().test("0000"));            // false
    System.out.println(predicate.and(predicate2).test("0123"));     // true
    System.out.println(predicate.or(predicate2).test("0000"));      // true