JUC介绍--四大函数式接口(Function Predicate Consumer Supplier)

函数式接口：只有一个方法的接口

Function函数式接口：一个参数，一个返回值

源码

@FunctionalInterface
public interface Function<T, R> {//泛型T：传入的参数类型 泛型R：返回的类型
    R apply(T t);//传入一个参数

    //一般使用时不考虑default的方法
    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函数式接口,有一个输入参数 一个返回参数
函数式接口都可以用lambda表达式简化
 */
public class FunctionDemo01 {
    public static void main(String[] args) {
        Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String str) {
                return str+"666";
            }
        };
        Function<String, String> function1 = (str)->{return str+"888";};
        Function<String, String> function2 = str->str+"555";

        System.out.println(function.apply("shuishusi"));
        System.out.println(function1.apply("shuishusi"));
        System.out.println(function2.apply("shuishusi"));
    }
}

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

测试

//判断型接口:有一个输入参数,返回一个布尔值
public class PredicateDemo {
    public static void main(String[] args) {
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String str) {
                return str.isEmpty();
            }
        };
        Predicate<String> predicate1 = (str)->{return str.isEmpty();};
        Predicate<String> predicate2 = str->str.isEmpty();
        Predicate<String> predicate3 = String::isEmpty;

        System.out.println(predicate.test("fdhg"));//false
        System.out.println(predicate1.test(""));//true
        System.out.println(predicate2.test("666"));//false
        System.out.println(predicate3.test("888"));//false
    }
}

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

测试：

//Consumer消费型接口 传入一个参数,没有返回值;有输入,没输出
public class CustomerDemo {
    public static void main(String[] args) {
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s+"666");
            }
        };
        Consumer<String> consumer1 = (str)->{System.out.println(str+"666");};
        Consumer<String> consumer2 = str->System.out.println(str+"666");

        consumer.accept("W");
        consumer1.accept("H");
        consumer2.accept("B");
    }
}

Supplier供给型接口：没有参数只有返回值

源码：

@FunctionalInterface
public interface Supplier<T> {//传入返回值类型
    T get();
}

测试：

//Supplier供给型接口 没有参数只有返回值
public class SupplierDemo {
    public static void main(String[] args) {
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "1024";
            }
        };

        Supplier<String> supplier1 = ()->{return "1024";};
        Supplier<String> supplier2 = ()->"1024";

        System.out.println(supplier.get());
        System.out.println(supplier1.get());
        System.out.println(supplier2.get());
    }
}