java 8 新特性之函数式接口

概述

什么是函数式接口？简单来说就是只有一个抽象函数的接口。java8提供了@FunctionalInterface注解告诉编译器去检查函数式接口的合法性，以便在编译出错时给出提示。函数式接口有以下三个规则

• 有且仅有一个抽象函数
• 有@FunctionalInterface注解
• 可以有默认方法

函数式接口的定义非常简单例如Runnable 接口，它就是一个函数式接口：

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

 现在我们使用Lambda表达式简化代码开发

 

new Thread().start(()->{
    System.out.println("hello world");
});

java8 util.function 包下自带了43个函数，可以分为以下几类

• Consumer 消费接口
• Function 功能接口
• Operator 操作接口
• Predicate 断言接口
• Supplier 生产接口

其他接口都是在上述接口基础上衍生出的

函数式接口详解

消费者接口，用来消费传递过来的数据

@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接口中有一个accept抽象方法，accpet接受一个变量，返回值为void;andThen是一个默认方法，接收一个Consumer对象。

Function

什么是Function呢？Function提供从一种类型到另一种类型的转换

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

Function接口最主要的就是apply方法，apply接收T类型的数据并返回R类型的数据，它还提供了compose、andThen、identity三个默认方法， compose接收一个Function,andThen也接收一个Function,identity起到了类似截流的作用。

Operator

可以简单的理解为算数运算操作，由于没有最基础的Operator，这里将通过BinaryOperator,IntBinaryOperator来理解Operator 函数式接口

IntBinaryOperator

 这是一个二元操作，并且输入输出参数都是Int类型

@FunctionalInterface
public interface IntBinaryOperator {

   
    int applyAsInt(int left, int right);
}

BinaryOperator

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

BinaryOperator自身定义了minBy,maxBy默认方法，并且都是Comparator，就是根据传入的比较器的比较规则找出最小最大的数据

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

Predicate的test接收T类型的数据，返回boolean类型，即对数据进行布尔运算

Supplier

生产数据即无中生有

@FunctionalInterface
public interface Supplier<T> {

  
    T get();
}