函数式接口的简单理解

函数式接口(都只有一个需要我们实现的方法)

1. 函数式接口 Function

@FunctionalInterface
public interface Function<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));
    }

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

使用

//函数式接口
// 传入 T
// 返回 R
public class functionTest {

    public static void main(String[] args) {
        //            T         R
        new Function<String, String>() {
            @Override
            public String apply(String t) {
                return "R";
            }
        };

         new Thread(() -> {
             System.out.println(123);
         });

        Function f = new Function<String, String>() {
            @Override
            public String apply(String o) {
                return "123";
            }
        };
        Function f1 = (str) -> { return str; };
        System.out.println(f1.apply("112"));
    }
}

2. 供给型接口 Supplier

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

// 供给型接口
//  无传入
//  返回T
public class supplierTest {
    public static void main(String[] args) {
        new Supplier<String>() {
            @Override
            public String get() {
                return "123";
            }
        };

        Supplier<String> supplier = () -> {return "123";};
    }
}

3. 断言型接口 Predicate

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

//断言型接口
// 传入 T
// 返回一个boolean值
public class predicateTest {

    public static void main(String[] args) {

        Predicate<String> pr = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.equals("123");
            }
        };
        Predicate<String> s = (srt) -> { return srt.isEmpty();};

    }
}

4. 消费型接口 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); };
    }
}

//消费型接口
// 传入 T
// 返回void
public class consumerTest {
    public static void main(String[] args) {
        Consumer c = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println("123");
            }
        };

        Consumer<String> s = (str) ->{
            System.out.println(123);
        };
        s.accept("789");
    }
}