理解 @FunctionalInterface

用于函数式接口类型声明的信息注解类型。
函数式接口只能有一个抽象方法，并排除接口默认方法以及声明中覆盖Object的公开方法的统计。
@FunctionalInterface不能标注在注解、类、枚举类上。
只要满足以上函数式接口的要求，无论接口声明中是否标注了@FunctionalInterface注解，均可以被编译器视作函数式接口。

函数式接口类型

提供类型 - Supplier<T>

@FunctionalInterface
public interface Supplier<T> {

    /**
     * 获取一个数据，入参为空，返回一个值
     * 相当于一个无入参且返回值为T的函数
     */
    T get();
}

消费类型 - Consumer<T>

@FunctionalInterface
public interface Consumer<T> {

   /**
   	* 接收一个值，做某些操作。参数传递进来后，要做什么。
   	* 相当于一个入参为T且无返回值的函数
   	*/
    void accept(T t);

   /**
   	* 相当于Builder模式。Fluent API
   	* 当传入一个值后，做完第一个操作，接下来要做什么
   	*/
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

转换类型 - Function<T,R>

@FunctionalInterface
public interface Function<T, R> {

    /**
     * 转换操作，接收两个类型，
     * 将 T 类型的数据 转换为 R 类型的数据。
     * 相当于一个入参为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));
    }

    /**
     * 一个永远返回 入参 的函数
   	 * 返回一个函数，它总是返回输入参数。调用该方法可以得到一个返回输入参数的Funtion
   	 * 这个Function就可以单纯的用来做数据处理，而不用类型转换
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

举个栗子：

Function<String, Long> stringToLong = Long::parseLong;

Function<Long, String> longToString = String::valueOf;

Function<Integer,String> intToString = String::valueOf;

stringToLong.apply 的意思是，接收一个string 返回一个Long

stringToLong.compose 的意思是，接收一个 Function<V,String>的函数式接口，这个函数式接口，接收一个V类型的参数，返回值是String类型，然后，再次同过stringToLong将返回值String 转换为 Long。这个操作是在执行完V To String 的操作后，再执行 stringToLong 的操作。

操作流程 V -> String > Long

stringToLong.andThen的意思是，接受一个Function<Long,V>的函数式接口，这个函数式接口，接收一个Long类型的参数，返回一个 V类型参数。这个操作是在执行完stringToLong后，接下来执行Long To V的操作。

操作流程 String -> Long -> V

断定类型 - Predicate<T>

@FunctionalInterface
public interface Predicate<T> {

    /**
     * 接收一个参数，返回值表示，当前参数是否符合预期要求
     * 相当于一个入参为T，返回值为boolean的函数
     */
    boolean test(T t);

	/**
	 * and 条件，相当于  条件A && 条件B
	 */
    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);
    }


    /**
     * or 条件  相当于  条件A||条件B
     */
    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);
    }
}

隐藏类型 - Action
- 类似于Runnable接口，无返回值，无入参。

旺仔没馒头

java8函数式编程初探

理解 @FunctionalInterface

函数式接口类型