Java8之函数式接口

定义

        只有一个方法的接口；可以被隐式转换成Lambda表达式；可以用@FunctionalInterface注解标识（注解非必须使用）

@FunctionalInterface注解

        自定义函数式接口也可不加注解，该注解只是起到一个提示编译器进行规范检查的作用

1.函数型接口：Function

有一个输入参数，有一个输出

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

apply ()方法就是该接口的唯一方法，也就是继承该Function接口，唯一需要实现的方法；其中传入两个泛型：T为参数类型，R为方法返回类型。

        Function<String,String> function = new Function<String, String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };

        //str是一个参数传递到 Predicate 接口的 apply 方法 。表示接受一个参数并产生结果
        System.out.println(function.apply("abc"));

        /**
         * lambda表达式来简化代码
         */
        Function<String,String> function2 = (String str) -> {return str;};
        System.out.println(function2.apply("abc"));

2.断定型接口：Predicate

有一个输入参数，返回值只能是布尔值

@FunctionalInterface
public interface Predicate<T> {
 
    // 在给定的参数上评估这个谓词
    boolean test(T t);
}

Predicate<Integer> predicate = new Predicate<Integer>(){
            @Override
            public boolean test(Integer n) {
                return n>0;
            }
        };

        System.out.println(predicate.test(2));
        /**
         * lambda表达式来简化代码
         */
        Predicate<Integer> predicate2 =(n)->{return n>0;};
        System.out.println(predicate2.test(2));

3.消费型接口：Consumer

消费型接口，即只消费，没有返回值

@FunctionalInterface
public interface Consumer<T> {
 
    // t 是输入参数
    void accept(T t);
}

Consumer<String> consumer = new Consumer<String>(){
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };


        consumer.accept("abc");
        /**
         * lambda表达式来简化代码
         */
        Consumer<String> consumer2 = str-> System.out.println(str);
        consumer2.accept("abc");

4.供给型接口：Supplier

没有参数，只有返回值

@FunctionalInterface
public interface Supplier<T> {
 
    // 获得结果 T是结果的具体类型
    T get();
}

 Supplier<Integer> consumer = new Supplier<Integer>(){
            @Override
            public Integer get() {
                return 1024;
            }
        };

        System.out.println(consumer.get());
        /**
         * lambda表达式来简化代码
         */
        Supplier<Integer> supplier = ()-> 1024;

        System.out.println(supplier.get());

供给型接口，顾名思义只提供，即返回结果，类似生产者