Java8 最重要的四种函数式接口及其作用

 

可以这么说，函数式接口中只能有一个抽象方法，可以有实现的静态方法；

@FunctionalInterface这个只是一个编译级的注解，用来检测你编写的函数式接口是否有错的

@FunctionalInterface
interface TestInterface {

     public  final  static String value ="111";
     static void staticFuc(){
          
     }
     void  Test();
}

他共有四种核心的函数式接口

一、功能性接口：Function  接收一个功能参数t，并返回一个功能结果R。

package java.util.function;
import java.util.Objects;


@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<String,String> function = (str) -> "hello,"+str;

        Function<String,String> function = (str) ->{
            return "hello,"+str;
        };
        String str = function.apply("Tassel");
        System.out.println(str);

二、断言性接口：Predicate  主要用到test方法 其中参数t为输入参数，如果输入参数符合断言则返回true，否则false

package java.util.function;
import java.util.Objects;
@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);
    }
}

举例子：下面的等价于  "Hello".equalsIgnoreCase(t) //t:输入参数

        Predicate<String> predicate = "Hello"::equalsIgnoreCase;
        System.out.println(predicate.test("Hello"));

三、供给性接口：Supplier 不接收任何参数 但有返回值

@FunctionalInterface
public interface Supplier<T> {

    T get();
}

        Supplier supplier = "Hello"::toLowerCase;
        System.out.println(supplier);

四、消费性接口：Consumer   只接收一个参数t，但是没有返回值。

package java.util.function;

import java.util.Objects;

@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<String> consumer = System.out ::println;
        consumer.accept("1111");

        ArrayList<String> arrayList = new ArrayList<>();
        Consumer<ArrayList> consumer = (e)-> e.add("111");