java复习随笔（十二）——函数式接口

函数式接口概述

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

如何检测一个接口是不是函数式接口呢？

• @FunctionalInterface
• 放在接口定义的上方：如果接口是函数式接口，编译通过，如果不是，编译失败。

我们自己定义函数式接口的时候，@FunctionInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

如果方法参数是函数式接口，那么可以使用Lambda表达式作为参数传入。示例代码如下：

public class Demo02 {
    public static void main(String[] args){
        Thread t01 = st(()->{
            for(int i = 0 ;i < 100;i++){
                System.out.println(i);
            }
        });
 
        Thread t02 = st(()->{
            for(int i = 0 ;i < 100;i++){
                System.out.println(i);
            }
        });
 
    }
 
    private static Thread st(Runnable r){
        Thread temp = new Thread(r);
        temp.start();
        return temp;
    }
}

如果方法的返回值是一个函数式接口，那么可以使用Lambda表达式作为结果返回。示例代码如下：

public class Demo03 {
    public static void main(String[] args){
        ArrayList<String> al = new ArrayList<>();
        al.add("aaa");
        al.add("cc");
        al.add("bbbb");
        al.add("d");
        Collections.sort(al,getComparator());
        System.out.println(al);
    }
    static Comparator<String> getComparator(){
       return (s1,s2)->s1.length()-s2.length();
    }
}

常用函数式接口

java8在java.util.function包下预定义了大量的函数式接口供我们使用
下面是常用的四个接口

• Supplier接口
• Consumer接口
• Predicate接口
• Function接口

Supplier生产型接口

Supplier<T>：包含一个无参的方法

• T get()：获得结果
• 该方法不需要参数，它会按照某种实现的逻辑（由Lambda表达实现）返回一个数据
• Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get()方法就会生产什么类型的数据供我们使用。

示例代码如下：

public class SupplierDemo {
    public static void main(String[] args){
        String s = useSupplier(()-> "HelloWorld!");
        System.out.println(s);
    }
    static String useSupplier(Supplier<String> sp){
        return sp.get();
    }
}

Consumer消费型接口

Consumer<T>：包含两个方法

• void accept(T t)：对给定的参数执行此操作
• default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer,依次执行此操作，然后执行after操作
• Consumer<T>：接口也被称为消费型接口，它消费的数据类型由泛型指定

示例代码如下：

public class Demo05 {
    public static void main(String[] args){
        // 重载方法一
        useConsumer(()->"你好世界！",(s)->{
            String str = new StringBuilder(s).reverse().toString();
            System.out.println(str);
        });
 
        System.out.println("————这是分割线————");
        // 重载方法二
        useConsumer("HelloWorld！！！",System.out::println,s->{
            String str = new StringBuilder(s).reverse().toString();
            System.out.println(str);
        });
    }
    static void useConsumer(Supplier<String> sp, Consumer<String> con){
        con.accept(sp.get());
    }
    static void useConsumer(String s,Consumer<String> con1,Consumer<String> con2){
        con1.andThen(con2).accept(s);
    }
}

Predicate接口

Predicate<T>：常用四个方法

• boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值
• default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非
• default Predicate <T> and(Predicate other)：返回一个组合判断，对应短路与
• default Predicate <T> or(Predicate other)：返回一个组合判断，对应短路或
  Predicate<T> 接口通常用于判断参数是否满足条件

1. test方法

public class PredicateDemo {
    public static void main(String[  ] args){
        boolean tof = usePredicate("HelloWorld！",s->s.length()>8);
        System.out.println(tof);
        tof = usePredicate("Hello！",s->s.length()>8);
        System.out.println(tof);
    }
    static boolean usePredicate(String s , Predicate<String> pd){
        return pd.test(s);
    }
}

2. 其他方法的使用

pd.negate().test(s);
pd1.and(pd2).test(s);
pd1.or(pd2).test(s);

• 2.1 negate、and、or源码

default Predicate<T> negate() {
    return (t) -> !test(t);
}
 
default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}
 
default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

Function接口

Function<T,R>：常用两个方法

• R apply(T t) ：将此函数应用于给定的参数
• default<V> Function adnThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
• Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑由lambda表达式实现，然后返回一个新的值）

代码示例如下：

public class FunctionDemo {
    public static void main(String[] args){
//        int num = convert("1666",s->Integer.parseInt(s));
        int num = convert("7777",Integer::parseInt);
        System.out.println(num);
    }
 
    private static int convert(String s,Function<String , Integer> func){
        return func.apply(s);
    }
}