Lambda表达式、函数式接口

Lambda表达式

      理解为对某一个接口中的抽象方法的匿名重写
      前提
         1.一定是接口
         2.接口中有且只有一个抽象方法

      标准格式
         ()->{}

         ():参数列表  数据类型 参数名 , 数据类型 参数名
         ->:固定写法  代表指向动作
         {}:方法体

      省略格式
          可推导的就是可省略的
         1.参数类型可以省略
         2.如果只有一个参数 ()可以省略
         3.如果方法体只有一句话 return 大括号 ; 都可以省略
           但是必须同时省略

代码实现:

public class Demo01_Lambda {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程任务");
            }
        }).start();
        new Thread(()->{
            System.out.println("线程任务");
        }).start();
        //省略格式
        new Thread(()-> System.out.println("线程任务"));
    }
}

ublic class Demo02_Lambda {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        list.add(10);
        list.add(20);
        list.add(40);
        list.add(30);

//        Collections.sort(list, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o2 - o1;
//            }
//        });
        Collections.sort(list,(Integer i1 ,Integer i2)->{
            return  i1 - i2;
        });
        System.out.println(list);
        //省略格式
        Collections.sort(list,(a,b)->a-b);
        System.out.println(list);
    }
}

public class Demo03_Lambda {
    public static void main(String[] args) {
        File dir = new File("d:\\work");
        //Lambda标准格式
//        File[] fileArr = dir.listFiles((File f)->{
//            return f.getName().toLowerCase().endsWith(".jpg");
//        });
        //省略格式
        File[] fileArr = dir.listFiles(f -> f.getName().toLowerCase().endsWith(".jpg"));
        for (File file : fileArr) {
            System.out.println(file);
        }
    }
}

Lambda表达式原理
在类中新增一个方法,这个方法的方法体就是Lambda表达式中的代码
还会形成一个内部类,实现接口,重写抽象方法
在接口的重写方法中会调用新生成的方法.

代码实现:

public class Test {
    public static void main(String[] args) {
//            method(new Fly() {
//                @Override
//                public void fly() {
//                    System.out.println("老子会飞");
//                }
//            });
        method(()->{
            System.out.println("老子会飞!");
        });
    }
    public static void method(Fly f){
        System.out.println("飞了");
        f.fly();
    }
}

public interface Fly {
    public abstract  void fly();
}

函数式接口

 有且仅有一个抽象方法的接口 称为函数式接口
 函数式接口 可以有默认方法 和 静态方法
 可以使用@FunctionalInterface来验证是否是函数式接口 如果是 不报错 如果不是编译报错

代码实现:

FunctionalInterface
public interface MyInterface {
    //有且仅有一个抽象方法的接口
    public abstract  void method();
   // public abstract  void method2();
    public default  void method3(){
        System.out.println("默认方法 给实现类使用 ");
    }
    public static void method4(){
        System.out.println("静态方法 接口自己使用");
    }
}
/*
     我们要学习的是  看到一个方法的参数是函数式接口时 如何写lambda表达式
 */
public class Test {
    public static void main(String[] args) {

        //标准格式
        method(()->{
            System.out.println("匿名重写方法");
        });

        method(()-> System.out.println("省略格式 匿名重写方法"));
    }
    public static void method(MyInterface mi){
            mi.method();
    }
}

Supplier接口

java.util.function.Supplier接口，它意味着"供给" , 对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
T get()

代码实现:

public class Demo01_Supplier {
    public static void main(String[] args) {
        int[] arr = {3,8,2,5,0};
        method(()->{
            Arrays.sort(arr);
            return arr[arr.length - 1];
        });
    }
    public static void method(Supplier<Integer> s){
        Integer max = s.get();
        System.out.println(max);
    }
}

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

void accept(T t)
代码实现:

public class Demo02_Consumer {
    public static void main(String[] args) {
        //标准格式
        method("Hello World",(String s)->{
            System.out.println(s.toUpperCase());
        });
        //省略格式
        method("Hello World",s-> System.out.println(s.toLowerCase()));

    }
    public static void method(String s , Consumer<String> c){
            c.accept(s);
    }
}

Consumer 默认方法
public default Consumer andThen(Consumer c)

public class Demo03_Consumer {
    public static void main(String[] args) {
        //标准格式
        method("Hello World",(String s)->{
            System.out.println(s.toUpperCase());
        },(String s) -> {
            System.out.println(s.toLowerCase());
        });
        //省略格式
        method("Hello World",s-> System.out.println(s.toUpperCase()),s-> System.out.println(s.toLowerCase()));

    }
    public static void method(String s, Consumer<String> c1,Consumer<String> c2){
//            c1.accept(s);
//            c2.accept(s);
        c1.andThen(c2).accept(s);
    }
}

今日总结:😁
明日计划:💪