java8函数式接口

一、函数式接口

1、函数式接口在java中是指:
有且仅有一个抽象方法的接口，函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现就是Lambda，所以函数式接口就是可以 适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
2、函数式接口格式及自定义函数式接口：
①格式就是普通的接口定义，在接口类添加@FunctionalInterface注解即可

//自定义函数式接口
@FunctionalInterface
public interface Nick<T,R,U> {

  U apply(T t,R r);
}
//java自带函数式接口定义
@FunctionalInterface
public interface Supplier<T> {

  /**
   * Gets a result.
   *
   * @return a result
   */
  T get();
}

3、常用函数式接口

1160484-20191026140858371-1865838994.png

①Supplier ：作为一个供应者,自己生产数据

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

②Consumer：作为一个消费者,利用已经准备数据

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

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

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

⑤ UnaryOperator： 输入一个值转换为相同值输出

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

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

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

4、主要语法:

1、() -> 代表了 lambda的一个表达式
2、单行代码无需写return (无论函数式接口有没有返回值),花括号
3、多行代码必须写花括号,有返回值的一定要写返回值
4、单行代码且有参数的情况下可以不写 () 如 s->System.out.println(s)
5、(T t)中的参数类型可写可不写