1 @FunctionalInterface

用于函数式接口类型声明的信息注解类型，接口实例被Lamada表示。方法应用，或者构造器应用创建。

1.1 要求

  • 函数式接口只能有一个抽象方法。
  • 排除接口默认方法
  • 不能覆盖实现Object的公开方法

接口满足函数式接口的要求，无论是否标注@FunctionalInterface，均能被编译器视作函数式接口。

1.2 接口类型

1.2.1 Supplier
  1. @FunctionalInterface
  2. public interface Supplier<T> {
  3.     /**
  4.      * Gets a result.
  5.      *
  6.      * @return a result
  7.      */
  8.     T get();
  9. }

1.2.2 Consumer
  1. @FunctionalInterface
  2. public interface Consumer<T> {
  4.     /**
  5.      * Performs this operation on the given argument.
  6.      *
  7.      * @param t the input argument
  8.      */
  9.     void accept(T t);
  11.     /**
  12.      * Returns a composed {@code Consumer} that performs, in sequence, this
  13.      * operation followed by the {@code after} operation. If performing either
  14.      * operation throws an exception, it is relayed to the caller of the
  15.      * composed operation.  If performing this operation throws an exception,
  16.      * the {@code after} operation will not be performed.
  17.      *
  18.      * @param after the operation to perform after this operation
  19.      * @return a composed {@code Consumer} that performs in sequence this
  20.      * operation followed by the {@code after} operation
  21.      * @throws NullPointerException if {@code after} is null
  22.      */
  23.     default Consumer<T> andThen(Consumer<? super T> after) {
  24.         Objects.requireNonNull(after);
  25.         return (T t) -> { accept(t); after.accept(t); };
  26.     }
  27. }

1.2.3 Function

转换接口

  1. @FunctionalInterface
  2. public interface Function<T, R> {
  4.     /**
  5.      * Applies this function to the given argument.
  6.      *
  7.      * @param t the function argument
  8.      * @return the function result
  9.      */
  10.     R apply(T t);
  12.     /**
  13.      * Returns a composed function that first applies the {@code before}
  14.      * function to its input, and then applies this function to the result.
  15.      * If evaluation of either function throws an exception, it is relayed to
  16.      * the caller of the composed function.
  17.      *
  18.      * @param <V> the type of input to the {@code before} function, and to the
  19.      *           composed function
  20.      * @param before the function to apply before this function is applied
  21.      * @return a composed function that first applies the {@code before}
  22.      * function and then applies this function
  23.      * @throws NullPointerException if before is null
  24.      *
  25.      * @see #andThen(Function)
  26.      */
  27.     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
  28.         Objects.requireNonNull(before);
  29.         return (V v) -> apply(before.apply(v));
  30.     }
  32.     /**
  33.      * Returns a composed function that first applies this function to
  34.      * its input, and then applies the {@code after} function to the result.
  35.      * If evaluation of either function throws an exception, it is relayed to
  36.      * the caller of the composed function.
  37.      *
  38.      * @param <V> the type of output of the {@code after} function, and of the
  39.      *           composed function
  40.      * @param after the function to apply after this function is applied
  41.      * @return a composed function that first applies this function and then
  42.      * applies the {@code after} function
  43.      * @throws NullPointerException if after is null
  44.      *
  45.      * @see #compose(Function)
  46.      */
  47.     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
  48.         Objects.requireNonNull(after);
  49.         return (T t) -> after.apply(apply(t));
  50.     }
  52.     /**
  53.      * Returns a function that always returns its input argument.
  54.      *
  55.      * @param <T> the type of the input and output objects to the function
  56.      * @return a function that always returns its input argument
  57.      */
  58.     static <T> Function<T, T> identity() {
  59.         return t -> t;
  60.     }
  61. }

1.2.4 Predicate
  1. @FunctionalInterface
  2. public interface Predicate<T> {
  4.     /**
  5.      * Evaluates this predicate on the given argument.
  6.      *
  7.      * @param t the input argument
  8.      * @return {@code true} if the input argument matches the predicate,
  9.      * otherwise {@code false}
  10.      */
  11.     boolean test(T t);
  13.     /**
  14.      * Returns a composed predicate that represents a short-circuiting logical
  15.      * AND of this predicate and another.  When evaluating the composed
  16.      * predicate, if this predicate is {@code false}, then the {@code other}
  17.      * predicate is not evaluated.
  18.      *
  19.      * <p>Any exceptions thrown during evaluation of either predicate are relayed
  20.      * to the caller; if evaluation of this predicate throws an exception, the
  21.      * {@code other} predicate will not be evaluated.
  22.      *
  23.      * @param other a predicate that will be logically-ANDed with this
  24.      *              predicate
  25.      * @return a composed predicate that represents the short-circuiting logical
  26.      * AND of this predicate and the {@code other} predicate
  27.      * @throws NullPointerException if other is null
  28.      */
  29.     default Predicate<T> and(Predicate<? super T> other) {
  30.         Objects.requireNonNull(other);
  31.         return (t) -> test(t) && other.test(t);
  32.     }
  34.     /**
  35.      * Returns a predicate that represents the logical negation of this
  36.      * predicate.
  37.      *
  38.      * @return a predicate that represents the logical negation of this
  39.      * predicate
  40.      */
  41.     default Predicate<T> negate() {
  42.         return (t) -> !test(t);
  43.     }
  45.     /**
  46.      * Returns a composed predicate that represents a short-circuiting logical
  47.      * OR of this predicate and another.  When evaluating the composed
  48.      * predicate, if this predicate is {@code true}, then the {@code other}
  49.      * predicate is not evaluated.
  50.      *
  51.      * <p>Any exceptions thrown during evaluation of either predicate are relayed
  52.      * to the caller; if evaluation of this predicate throws an exception, the
  53.      * {@code other} predicate will not be evaluated.
  54.      *
  55.      * @param other a predicate that will be logically-ORed with this
  56.      *              predicate
  57.      * @return a composed predicate that represents the short-circuiting logical
  58.      * OR of this predicate and the {@code other} predicate
  59.      * @throws NullPointerException if other is null
  60.      */
  61.     default Predicate<T> or(Predicate<? super T> other) {
  62.         Objects.requireNonNull(other);
  63.         return (t) -> test(t) || other.test(t);
  64.     }
  66.     /**
  67.      * Returns a predicate that tests if two arguments are equal according
  68.      * to {@link Objects#equals(Object, Object)}.
  69.      *
  70.      * @param <T> the type of arguments to the predicate
  71.      * @param targetRef the object reference with which to compare for equality,
  72.      *               which may be {@code null}
  73.      * @return a predicate that tests if two arguments are equal according
  74.      * to {@link Objects#equals(Object, Object)}
  75.      */
  76.     static <T> Predicate<T> isEqual(Object targetRef) {
  77.         return (null == targetRef)
  78.                 ? Objects::isNull
  79.                 : object -> targetRef.equals(object);
  80.     }
  81. }

1.2.5 Runnable
  1. @FunctionalInterface
  2. public interface Runnable {
  3.     /**
  4.      * When an object implementing interface <code>Runnable</code> is used
  5.      * to create a thread, starting the thread causes the object's
  6.      * <code>run</code> method to be called in that separately executing
  7.      * thread.
  8.      * <p>
  9.      * The general contract of the method <code>run</code> is that it may
  10.      * take any action whatsoever.
  11.      *
  12.      * @see     java.lang.Thread#run()
  13.      */
  14.     public abstract void run();
  15. }

1.3 原理

MethodHandle
InvokeDynamic

2 函数式接口设计

2.1 Supplier

  • 基本特点：只出不进
  • 编程范式：作为方法/构造参数，方法返回值
  • 使用场景：数据来源，代码替代接口。

  • 供应，加工数据。

    1. () -> {return data};

    2.2 Consumer

  • 基本特点：只进不出

  • 编程方式：作为犯法/构造参数
  • 使用场景：执行Callback

  • 消费，输出数据

    2.3 Function

  • 基本特点：有进有出

  • 编程范式：作为方法/构造参数

  • 使用场景：类型转换，业务处理

    1. Function<Number,Number> muility = (a) = a* a;
    2. Function<String, Long> stringToLong = Long::valueOf;

    2.4 Predicate

  • 基本特点：boolean类型判断。

  • 编程范式：作为方法/构造参数
  • 使用场景：过滤，对象比较等。
    1. num -> num %2 !=0;

    3 Stream API 设计

    3.1 转换Stream#map
    3.2 过滤Stream#filter
    3.3 排序Stream#Sorted
    Collect