CClown

一、概述：

函数式接口：有且仅有一个抽象方法的接口

注解：@FunctionalInterface

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

二、函数式接口作为方法的参数

如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递

public static void main(String[] args) {
        startThread(()->System.out.println(Thread.currentThread().getName()+"线程启动了"));

    }
public static void startThread(Runnable r) {
        Thread t1=new Thread(r);
        t1.start();
        System.out.println(t1.getName());
    }

三、函数式接口作为方法的返回值

如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回

public static void main(String[] args) {
        TreeSet<String> ts=new TreeSet<>(getComparator());
        ts.add("hello");
        ts.add("worlds");
        ts.add("你好啊");
        ts.add("世界");
        for(String i:ts){
            System.out.println(i);
        }

    }
    public static Comparator<String> getComparator(){
        return Comparator.comparingInt(String::length);
    }

四、常用的函数式接口：

（1）Supplier

（2）Consumer

（3）Predicate

（4）Function

1、Supplier<T>接口：

（1）T get()：获取结果

该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据

Supplier<T>接口也被称为生产型接口，如果我们制定了接口的泛型，那么接口的get()方法就会生产什么类型的数据供我们使用

public static void main(String[] args) {
    int[] arr={1,2,4,5,23,546,22,45,6};
    int c=getMAX(()->{
        int b=arr[0];
        for(int i:arr){
            b=Math.max(b, i);
        }
        return b;
    });
    System.out.println(c);
}
public static int getMAX(Supplier<Integer> sup){
    return sup.get();
}

2、Consumer<T>接口：

（1）void accept(T t):对给定的参数执行此操作

（2）default Consumer<T> andThen(Consumer after):返回一个组合的Consumer,依次执行此操作，然后执行after操作

Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

public static void main(String[] args) {
    String[] arr={"张三,18","李四,38","王五,32"};
    printName(arr,s -> System.out.println("姓名："+s.split(",")[0]),
    s -> System.out.println("年龄："+Integer.parseInt(s.split(",")[1])));

}


public static void printName(String[] arr,Consumer<String> con1,Consumer<String> con2){
    for(String i:arr){
        con1.andThen(con2).accept(i);
    }
}

3、Predicate<T>接口：

（1）boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现）返回一个布尔值

（2）default Predicate<T> negate()返回一个逻辑的否定，对应逻辑非

（3）default Predicate<T> and(Predicate other):返回一个组合判断，对应短路与

（4）default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或

Predicate<T>接口通常用于判断参数是否满足指定的条件

public static void main(String[] args) {
    String[] arr={"张三,19","李四哦,21","王五,24","赵六,17"};
    ArrayList<String> array=screen(arr,s -> s.split(",")[0].length()>2,s->Integer.parseInt(s.split(",")[1])>20);
    System.out.println(array);
}
public static ArrayList<String> screen(String[] s,Predicate<String> pre1,Predicate<String> pre2){
    ArrayList<String> array=new ArrayList<>();
    for(String i:s){
        if(pre1.and(pre2).test(i)){
            array.add(i);
        }
    }
    return array;
}

4、Function<T,R>接口：

（1）R apply(T t):将此函数应用于给定的参数

（2）default<V> Function andThen(Function after):返回一个组合参数，首先将该函数应用于输入，然后将after函数应用于结果

Function<T,R>接口经常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值

public static void main(String[] args) {
    convert("123", Integer::parseInt);
    convert("123",s->Integer.parseInt(s)+100,String::valueOf);
}
public static void convert(String s, Function<String,Integer> fun){
    System.out.println((int)fun.apply(s));
}
public static void convert(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
    System.out.println(fun1.andThen(fun2).apply(s));
}