JAVA8函数式接口使用

概念

函数式接口在java中是指:有且仅有一个抽象方法的接口

函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖"是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

格式

接口中只存在一个抽象方法，@FunctionalInterface 注解加不加都可以。

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。(该接口是一个标记接口)

修饰符 interface 接口名称{
    public abstract 返回值 方法名称(参数列表)
    // 其他方式 
}
// public abstract 可以不写 编译器自动加上
修饰符 interface 接口名称{
       返回值 方法名称(参数列表)
    // 其他方式 
}

@FunctionalInterface // 标明为函数式接口
public abstract MyFunctionInterface{
    void mrthod(); //抽象方法
}

调用自定义函数接口

public class Test_Functional {
    // 定义一个含有函数式接口的方法
    public static void doSomthing(MyFunctionalInterface functionalInterface) {
        functionalInterface.mehod();//调用自定义函数式接口的方法
    }
    public static void main(String[] args) {
        //调用函数式接口的方法
        doSomthing(()->System.out.println("excuter lambda!"));
    }
}

常用函数式接口

•    Supplier 你要作为一个供应者,自己生产数据
•    Consumer 你要作为一个消费者,利用已经准备数据
•    Function  输入一个或者两个不同或者相同的值转为另一个值
•    Predicate 输入一个或者两个不同或者相同的值总是输出boolean

主要语法:

1.  () -> 代表了 lambda的一个表达式
2.  单行代码无需写return (无论函数式接口有没有返回值),花括号
3.  多行代码必须写花括号,有返回值的一定要写返回值
4.  单行代码且有参数的情况下可以不写 ()   如  s->System.out.println(s)
5.  (T t)中的参数类型可写可不写

Supplier接口(供应接口)

java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。 

public class Test_Supplier {
    private static String test_Supplier(Supplier<String> suply) {
        return suply.get(); //供应者接口
    }
    public static void main(String[] args) {
         // 产生的数据作为 sout 作为输出
         System.out.println(test_Supplier(()->"产生数据"));
         
         System.out.println(String.valueOf(new Supplier<String>() {
             @Override
            public String get() {
                return "产生数据";
            }
        }));
    }
}

Consumer接口

java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：

public class Test_Consumer {
    public static void generateX(Consumer<String> consumer) {
        consumer.accept("hello consumer");
    }
    public static void main(String[] args) {
        generateX(s->System.out.println(s));
    }
}

默认方法：andThen：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) ‐> { accept(t); after.accept(t); }; 
    //1:  返回值为Consumer 那么需要 ()-> 表示函数式接口
    //2:  accept(t);为生产一个数据供应给 (T t)中的t
    //3:  after.accept(t);为利用这个t再次生成新的函数式接口 实现类始于builder的设计模式
}

public class Test_Consumer {
    private static void append(Consumer<Integer> con1, Consumer<Integer> con2) {
        con1.andThen(con2).accept(1);
    }
    public static void main(String[] args) {
        append((i) -> System.out.println(i + 1), (i) -> System.out.println(i + 2));
    }
}

 Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T> 接口

抽象方法：test

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：

默认方法：and or nagte (取反)

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。

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

public class Use_Predicate {
    // 判断字符串是否存在o  即使生产者 又是消费者接口
    private static void method_test(Predicate<String> predicate) {
         boolean b = predicate.test("OOM SOF");
         System.out.println(b);
    }
    // 判断字符串是否同时存在o h 同时
    private static void method_and(Predicate<String> predicate1,Predicate<String> predicate2) {
        boolean b = predicate1.and(predicate2).test("OOM SOF");
        System.out.println(b);
    }
    //判断字符串是否一方存在o h 
    private static void method_or(Predicate<String> predicate1,Predicate<String> predicate2) {
        boolean b = predicate1.or(predicate2).test("OOM SOF");
        System.out.println(b);
    }
    // 判断字符串不存在o 为真   相反结果
    private static void method_negate(Predicate<String> predicate) {
         boolean b = predicate.negate().test("OOM SOF");
         System.out.println(b);
    }
    public static void main(String[] args) {
        method_test((s)->s.contains("O"));
        method_and(s->s.contains("O"), s->s.contains("h"));
        method_or(s->s.contains("O"), s->s.contains("h"));
        method_negate(s->s.contains("O"));
    }
}

Function接口

 java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件

    // 将数字转换为String类型
    private static void numberToString(Function<Number, String> function) {
        String apply = function.apply(12);
        System.out.println("转换结果:"+apply);
    }
    public static void main(String[] args) {
        numberToString((s)->String.valueOf(s));
    }

Function 接口中有一个默认的 andThen  compose方法，用来进行组合操作。JDK源代码如：

    //两个方法的差别在于执行顺序的不同
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
     }  

     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    // 静态方法
    private static void method_andThen(Function<Integer, Integer> f1,Function<Integer, Integer> f2) {
        Integer apply = f1.andThen(f2).apply(2);
        System.out.println(apply);
    }
    private static void method_compose(Function<Integer, Integer> f1,Function<Integer, Integer> f2) {
        Integer apply = f1.compose(f2).apply(2);
        System.out.println(apply);
    }
    public static void main(String[] args) {
        numberToString((s)->String.valueOf(s));
        method_andThen(s->s+1, s->s=s*2);//6
        method_compose(s->s+1, s->s=s*s);//5
    }