Lambda表达式和函数式接口

函数式接口

定义：如果一个接口只有一个抽象方法，则这个接口就是函数式接口，函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上

@FunctionnalInterface注可以用来检测接口是否符合函数式接口

常见的函数式接口

Consumer消费性接口

消费型，有参无返回值
void accept(T t)：对类型为T的对象应用操作

public class ConsumerInterface {
    public static void main(String[] args) {
        //匿名内部类
        Consumer consumer = new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println(aDouble);
            }
        };
    ConsumerInterface(consumer,15.1);
        System.out.println("-------------内部类-------------------");

    //lambda表达式方法
        Consumer consumer1=(aDouble)-> System.out.println(aDouble);
        ConsumerInterface(consumer,15.1);
        System.out.println("-------------lambda表达式方法-------------------");
        //简化式lambda表达式方法

        ConsumerInterface(aDouble -> System.out.println(aDouble),15.1);
        System.out.println("-------------简单lambda表达式方法-------------------");
    }
    //定义消费型方法
    //消费型，有参无返回值
    public static void  ConsumerInterface(Consumer<Double> consumer,Double param){
        consumer.accept(param);
    }
}

supplier供给型函数式接口

供给性接口：无参有返回值
T get();返回类型为T的对象

public class SupplierInterface {
    public static void main(String[] args) {
    //内部类
        Supplier<String> supplier = new Supplier() {
            @Override
            public String get() {
                return "内部类";
            }
        };
        System.out.println(SupplierInterface(supplier));
        System.out.println("-------------内部类---------------");

    //普通Lambda表达式
        Supplier<String> supplier1= ()-> { return "普通Lambda表达式"; };

        String s = SupplierInterface(supplier1);
        System.out.println(s);
        System.out.println("-------------普通Lambda表达式---------------");

    //简单Lambda表达式
        System.out.println(SupplierInterface(() -> "简单Lambda表达式"));
        System.out.println("-------------简单Lambda表达式---------------");
    }

    //有参有返回值
    public static  String SupplierInterface(Supplier<String> supplier){
        return supplier.get();
    }
}

funcation函数性接口

function<T,R> T：参数类型 R：返回类型
R apply（T t）：对类型为T的对象进行操作，并返回类型为R类型的对象

public class FunctionInterface {
    public static void main(String[] args) {
        //内部类
        Function<Double,String> function = new Function<Double, String>() {
            @Override
            public String apply(Double aDouble) {
                return "内部类";
            }
        };
        System.out.println(functionInterface(function,15.0));
        System.out.println("---------------内部类------------");

        //lambda表达式
        Function<Double,String> function1= (d)->{ return "普通lambda表达式"+d/15; };
        String s = functionInterface(function1,15.0);
        System.out.println(s);
        System.out.println("---------------普通lambda表达式------------");

        //简单lambda表达式
        System.out.println(functionInterface((d) -> "简单lambda表达式" + d / 15, 30.0));
        System.out.println("---------------简单lambda表达式------------");
    }
    public  static String functionInterface(Function<Double,String> function,Double d){
        return function.apply(d);
    }
}

Lambda表达式

• Lambda表达式：特殊的匿名内部类，语法更简洁
• Lambda表达式允许把函数作为一个方法的参数（函数作为方法的参数传递），将代码像数据一样传输
• 基本语法

<函数式接口> <变量名> =(参数1，参数2) ->{
//方法体
}

实例

线程的Thread类
THread类的源码中有一个构造是可以传一个Runnable类，而恰好这个类是一个函数式接口

public class TreeTest {

    public static void main(String[] args) {
        //简单lambda
        TreeSet<Proson> prosons1 = new TreeSet<>((o1, o2) -> o1.getId() - o2.getId());
        //内部类
        Comparator comparator1 =new Comparator<Proson>() {
            @Override
            public int compare(Proson o1, Proson o2) {
               return   o1.getId()-o2.getId();
            }
        };
        //普通lambda
        Comparator<Proson> comparator =(o1,o2) ->{ return   o1.getId()-o2.getId(); };

        TreeSet<Proson> prosons = new TreeSet<>(comparator);
    }
}

@NoArgsConstructor
@AllArgsConstructor
@Data
class  Proson{
    private int id;
    private  String name;

}