JDK8的新特性（三）— —常用内置函数式接口

一、常用的内置函数式接口

因为lambda表达式的使用前提是函数式接口，为使用方便，JDK8为我们提供了一些常用的函数式接口。它们均位于java.util.function包中。其中有4个为我们日常使用率较高。Supplier、Function、Consumer、Perdicate

二、Supplier

java.util.function.Supplier，这是一个对外供给的接口。此接口无需参数，即可返回结果

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

使用示例：

public class TestSupplier {
    public static void main(String[] args) {
    	//调用方法，并定义lambda表达式
        String m1 = TestSupplier.m1(() -> "Test Supplier m1...");
        System.out.println("m1->" + m1);
    }

    //参数是Supplier函数式接口的静态方法
    public static String m1(Supplier<String> supplier){
        return supplier.get();
    }
}

==运行结果==
m1->Test Supplier m1...

二、Function

java.util.function.Function，这是一个转换的接口。此接口有参数、有返回值，传入T类型的数据，经过处理后，返回R类型的数据。

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
    
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
 }

使用示例：

public class TestFunction {
    public static void main(String[] args) {
        //调用方法m1，并定义lambda表达式
        Integer m1 = TestFunction.m1((t1) -> {
            return Integer.valueOf(t1);
        });
        System.out.println("m1->" + m1);

        System.out.println("------------------");
        //调用方法m2，并定义lambda表达式
        String m2 = TestFunction.m2(f1 -> {
            return Integer.valueOf(f1);
        }, f2 -> {
            return String.valueOf(f2);
        });
        System.out.println("m2->" + m2);
    }

    //参数是Function函数式接口的静态方法
    public static Integer m1(Function<String, Integer> function){
        return function.apply("999");
    }

    //参数是Function函数式接口的静态方法
    public static String m2(Function<String, Integer> f1, Function<Integer, String> f2){
        return f1.andThen(f2).apply("1000");
    }
}

==运行结果==
m1->999
------------------
m2->1000

三、Consumer

java.util.function.Consumer，这是一个消费的接口。此接口有参数，但是没有返回值

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

使用示例：

public class TestConsumer {
    public static void main(String[] args) {
        //调用方法m1，并定义lambda表达式
        TestConsumer.m1(c1->{
            System.out.println("c1->" + c1);
        });

        System.out.println("------------------");

        //调用方法m2，并定义lambda表达式
        TestConsumer.m2(c1->{
            System.out.println("c1->" + c1);
        }, c2->{
            System.out.println("c2->" + c2);
        });
    }

    //参数是Consumer函数式接口的静态方法
    public static void m1(Consumer<String> c1){
        c1.accept("Hello World");
    }

    //参数是Consumer函数式接口的静态方法
    public static void m2(Consumer<String> c1, Consumer<String> c2){
    	//andThen实现了两个Consumer对于同一个输入对象的先后使用
        c1.andThen(c2).accept("hello everyone");
    }
}

==运行结果==
c1->Hello World
------------------
c1->hello everyone
c2->hello everyone

四、Perdicate

java.util.function.Predicate，这是一个断言的接口。此接口对输入的参数进行一系列的判断，返回一个Boolean值。Predicate接口包含了多种默认方法，用于处理复杂的判断逻辑（and, or，negate，isEqual）

@FunctionalInterface
public interface Predicate<T> {
	//标准判断
    boolean test(T t);
	//计算两个Predicate的“与”逻辑
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
	//计算Predicate的“非”逻辑
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
	//计算两个Predicate的“或”逻辑
    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 TestPredicate {
    public static void main(String[] args) {
        Boolean m1Result = TestPredicate.m1(p1 -> {
            return p1.equals("Hello");
        });
        System.out.println("m1Result->" + m1Result);

        //调用两个Predicate的“与”逻辑
        Boolean m2Result = TestPredicate.m2(p1 -> p1.contains("H"), p2 -> p2.contains("d"));
        System.out.println("m2Result->" + m2Result);

        //调用两个Predicate的“或”逻辑
        Boolean m3Result = TestPredicate.m3(p1 -> p1.contains("z"), p2 -> p2.contains("d"));
        System.out.println("m3Result->" + m3Result);

        //调用Predicate的“非”逻辑
        Boolean m4Result = TestPredicate.m4(p1 -> p1.contains("H"));
        System.out.println("m4Result->" + m4Result);

        //调用Predicate的静态变量，检查两个值是否相等
        Boolean m5Result = TestPredicate.m5();
        System.out.println("m5Result->" + m5Result);
    }

    public static Boolean m1(Predicate<String> p1){
        return p1.test("Hello");
    }
    //计算两个Predicate的“与”逻辑
    public static Boolean m2(Predicate<String> p1, Predicate<String> p2){
        return p1.and(p2).test("Hello world");
    }

    //计算两个Predicate的“或”逻辑
    public static Boolean m3(Predicate<String> p1, Predicate<String> p2){
        return p1.or(p2).test("Hello world");
    }

    //计算Predicate的“非”逻辑
    public static Boolean m4(Predicate<String> p1){
        return p1.negate().test("Hello world");
    }

    public static Boolean m5(){
        return Predicate.isEqual("Hello world").test("Hello world");
    }
}

==运行结果==
m1Result->true
m2Result->true
m3Result->true
m4Result->false
m5Result->true