Java8之函数式接口

定义

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

@FunctionalInterface注解

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

1.函数型接口：Function

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

@FunctionalInterface
public interface Function {
 
    // 继承该接口需要实现的方法
    R apply(T t); 
 
    default  Function compose(Function before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
 
    default  Function andThen(Function after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
   
    static  Function identity() {
        return t -> t;
    }
}

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

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

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

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

2.断定型接口：Predicate

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

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

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

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

3.消费型接口：Consumer

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

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

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


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

4.供给型接口：Supplier

没有参数，只有返回值

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

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

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

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

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