函数式接口

  • 函数式接口:有且仅有一个抽象方法的接口。
  • 使用@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>: 输入是 TU 类型的数据,无返回值
  • BiPredicate<T, U>: 输入是 TU 类型的数据,返回 boolean 类型。
  • BiFunction<T, U, R>: 输入是 TU 类型的数据,返回 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
01-11 14:13