Java @FunctionalInterface 函数式接口

目录

• ​​函数式接口简介​​
• ​​jdk中常用的函数式接口​​

• ​​java.io包 FileFilter、FilenameFilter​​
• ​​java.lang包 Runnable​​
• ​​java.util.concurrent包 Callable​​
• ​​java.util包 Comparator​​
• ​​java.util.function包​​

• ​​Supplier生产者系列，获取指定类型的数据​​
• ​​Consumer消费者系列，消费、处理指定类型的数据，返回void​​
• ​​Function计算处理系列，返回指定类型​​
• ​​Operator操作系列，入参、返回值类型相同​​
• ​​Predicate断言系列，返回boolean​​

函数式接口简介

• 接口中的抽象方法（函数）有且仅有1个；允许同时存在默认方法等其它类型的方法。
• jdk8 新增的 @FunctionalInterface 注解，用于标记函数式接口；java编译器会把满足函数式接口定义的任何接口都视为函数式接口，不管这些接口上是否标注了 @FunctionalInterface。

jdk中常用的函数式接口

java.io包 FileFilter、FilenameFilter

@FunctionalInterface
public interface FileFilter {
    boolean accept(File pathname);
}

@FunctionalInterface
public interface FilenameFilter {
    boolean accept(File dir, String name);
}

java.lang包 Runnable

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

常和 Thread、Executor 搭配使用，如果只重写Thread的run方法，jdk官方更推荐通过 Runnable 来写 run() 方法的代码，这样不会将 run() 的代码与具体的某个 Thread 类耦合、绑定在一起，便于在其他地方复用 run() 的代码；如果还需要重写Thread的其它方法，才继承重写 Thread。

java.util.concurrent包 Callable

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

Callable 和 Runnable作用相似，都是通常和 Thread、Executor 搭配使用，区别在于

• Runnable#run() 是无参、无返回值的，Callable#call() 是无参、有返回值的，Callable 常用于数据计算、返回计算结果；
• Callable#call() 显式声明了异常，调用方必须处理该异常

java.util包 Comparator

比较器，用于实现元素比较，常在排序中使用

@FunctionalInterface
public interface Comparator<T> {
    
    int compare(T o1, T o2);

    boolean equals(Object obj);

    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    default Comparator<T> thenComparing(Comparator<? super T> other) {
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

    default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }

    default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }

    default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
        return thenComparing(comparingInt(keyExtractor));
    }

    default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
        return thenComparing(comparingLong(keyExtractor));
    }

    default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        return thenComparing(comparingDouble(keyExtractor));
    }

    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }

    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }

    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }
    
    public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(false, comparator);
    }

    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }

    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }

    public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
    }
    
    public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
    }
}

java.util.function包

这个包专门用于存放函数式接口，BiXxx系列都是2个入参
 

Supplier生产者系列，获取指定类型的数据

Supplier 提供者、供应商，以下几个函数式接口的区别在于获取的目标数据类型不同

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

@FunctionalInterface
public interface IntSupplier {
    int getAsInt();
}

@FunctionalInterface
public interface LongSupplier {
    long getAsLong();
}

@FunctionalInterface
public interface DoubleSupplier {
    double getAsDouble();
}

@FunctionalInterface
public interface BooleanSupplier {
    boolean getAsBoolean();
}

Consumer消费者系列，消费、处理指定类型的数据，返回void

以下几个函数式接口的区别在于 入参的类型、个数不同

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


@FunctionalInterface
public interface BiConsumer<T, U> {

    void accept(T t, U u);

    default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
        Objects.requireNonNull(after);

        return (l, r) -> {
            accept(l, r);
            after.accept(l, r);
        };
    }
}

@FunctionalInterface
public interface IntConsumer {

    void accept(int value);

    default IntConsumer andThen(IntConsumer after) {
        Objects.requireNonNull(after);
        return (int t) -> { accept(t); after.accept(t); };
    }
}


@FunctionalInterface
public interface LongConsumer {

    void accept(long value);

    default LongConsumer andThen(LongConsumer after) {
        Objects.requireNonNull(after);
        return (long t) -> { accept(t); after.accept(t); };
    }
}


@FunctionalInterface
public interface DoubleConsumer {

    void accept(double value);

    default DoubleConsumer andThen(DoubleConsumer after) {
        Objects.requireNonNull(after);
        return (double t) -> { accept(t); after.accept(t); };
    }
}

@FunctionalInterface
public interface ObjIntConsumer<T> {
    void accept(T t, int value);
}

@FunctionalInterface
public interface ObjLongConsumer<T> {
    void accept(T t, long value);
}

@FunctionalInterface
public interface ObjDoubleConsumer<T> {
    void accept(T t, double value);
}

Function计算处理系列，返回指定类型

和Consumer的区别在于有返回值。以下几个函数式接口的区别在于 入参类型、入参个数、返回值类型不同

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

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


@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);

    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

XxxFunction，Xxx为入参类型，返回值类型由泛型指定

@FunctionalInterface
public interface IntFunction<R> {
    R apply(int value);
}

@FunctionalInterface
public interface LongFunction<R> {
    R apply(long value);
}

@FunctionalInterface
public interface DoubleFunction<R> {
    R apply(double value);
}

AToBFunction，A为入参类型，B为返回值类型

@FunctionalInterface
public interface IntToLongFunction {
    long applyAsLong(int value);
}

@FunctionalInterface
public interface IntToDoubleFunction {
    double applyAsDouble(int value);
}


@FunctionalInterface
public interface LongToIntFunction {
    int applyAsInt(long value);
}

@FunctionalInterface
public interface LongToDoubleFunction {
    double applyAsDouble(long value);
}


@FunctionalInterface
public interface DoubleToIntFunction {
    int applyAsInt(double value);
}

@FunctionalInterface
public interface DoubleToLongFunction {
    long applyAsLong(double value);
}

ToXxxFunction，Xxx为返回值类型，入参类型由泛型指定

@FunctionalInterface
public interface ToIntFunction<T> {
    int applyAsInt(T value);
}

@FunctionalInterface
public interface ToIntBiFunction<T, U> {
    int applyAsInt(T t, U u);
}


@FunctionalInterface
public interface ToLongFunction<T> {
    long applyAsLong(T value);
}

@FunctionalInterface
public interface ToLongBiFunction<T, U> {
    long applyAsLong(T t, U u);
}


@FunctionalInterface
public interface ToDoubleFunction<T> {
    double applyAsDouble(T value);
}

@FunctionalInterface
public interface ToDoubleBiFunction<T, U> {
    double applyAsDouble(T t, U u);
}

Operator操作系列，入参、返回值类型相同

与 Function 系列类似，都是对入参进行计算、处理，返回指定类型的结果，区别在于

• Function 系列不要求入参、返回值类型相同，有多个入参时不要求入参类型相同；
• Operator 系列要求入参、返回值类型相同，有多个入参时要求入参类型相同。

Operator 可以简单看作入参、返回值类型相同的 Function。
 

Unary：一元，即1个参数；Binary：二元，即2个参数。

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

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


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

@FunctionalInterface
public interface IntUnaryOperator {

    int applyAsInt(int operand);

    default IntUnaryOperator compose(IntUnaryOperator before) {
        Objects.requireNonNull(before);
        return (int v) -> applyAsInt(before.applyAsInt(v));
    }
    
    default IntUnaryOperator andThen(IntUnaryOperator after) {
        Objects.requireNonNull(after);
        return (int t) -> after.applyAsInt(applyAsInt(t));
    }
    
    static IntUnaryOperator identity() {
        return t -> t;
    }
}


@FunctionalInterface
public interface LongUnaryOperator {

    long applyAsLong(long operand);

    default LongUnaryOperator compose(LongUnaryOperator before) {
        Objects.requireNonNull(before);
        return (long v) -> applyAsLong(before.applyAsLong(v));
    }

    default LongUnaryOperator andThen(LongUnaryOperator after) {
        Objects.requireNonNull(after);
        return (long t) -> after.applyAsLong(applyAsLong(t));
    }

    static LongUnaryOperator identity() {
        return t -> t;
    }
}


@FunctionalInterface
public interface DoubleUnaryOperator {

    double applyAsDouble(double operand);

    default DoubleUnaryOperator compose(DoubleUnaryOperator before) {
        Objects.requireNonNull(before);
        return (double v) -> applyAsDouble(before.applyAsDouble(v));
    }

    default DoubleUnaryOperator andThen(DoubleUnaryOperator after) {
        Objects.requireNonNull(after);
        return (double t) -> after.applyAsDouble(applyAsDouble(t));
    }

    static DoubleUnaryOperator identity() {
        return t -> t;
    }
}

@FunctionalInterface
public interface IntBinaryOperator {
    int applyAsInt(int left, int right);
}

@FunctionalInterface
public interface LongBinaryOperator {
    long applyAsLong(long left, long right);
}

@FunctionalInterface
public interface DoubleBinaryOperator {
    double applyAsDouble(double left, double right);
}

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

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}


@FunctionalInterface
public interface BiPredicate<T, U> {

    boolean test(T t, U u);

    default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> other) {
        Objects.requireNonNull(other);
        return (T t, U u) -> test(t, u) && other.test(t, u);
    }

    default BiPredicate<T, U> negate() {
        return (T t, U u) -> !test(t, u);
    }

    default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> other) {
        Objects.requireNonNull(other);
        return (T t, U u) -> test(t, u) || other.test(t, u);
    }
}

XxxPredicate，Xxx为入参类型

@FunctionalInterface
public interface IntPredicate {

    boolean test(int value);

    default IntPredicate and(IntPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) && other.test(value);
    }

    default IntPredicate negate() {
        return (value) -> !test(value);
    }

    default IntPredicate or(IntPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) || other.test(value);
    }
}

@FunctionalInterface
public interface LongPredicate {

    boolean test(long value);

    default LongPredicate and(LongPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) && other.test(value);
    }

    default LongPredicate negate() {
        return (value) -> !test(value);
    }

    default LongPredicate or(LongPredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) || other.test(value);
    }
}


@FunctionalInterface
public interface DoublePredicate {

    boolean test(double value);

    default DoublePredicate and(DoublePredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) && other.test(value);
    }

    default DoublePredicate negate() {
        return (value) -> !test(value);
    }

    default DoublePredicate or(DoublePredicate other) {
        Objects.requireNonNull(other);
        return (value) -> test(value) || other.test(value);
    }
}