Lambda表达式

Lambda表达式

大纲

具体案例

-> ：lambda操作符或者箭头操作符
-> 左边：lambda形参列表 (其实就是接口中的抽象方法的形参列表)
-> 右边：lambda体 （其实就是重写的抽象方法的方法体）

lambda的使用

本质(Java中)：作为接口的实例

无参，无返回值

public class lambdaTest1 {
    @Test
    public void test() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("传统写法");
            }
        };
        r1.run();
        // 无参，无返回值的lambda
         Runnable r2 = () -> {
            System.out.println("lambda 写法");
        };
        r2.run();
    }
}

一个参数，无返回值

public class lambdaTest2 {
    @Test
    public void test(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("传统方法");

        // lambda 表达式方法，需要一个参数，无返回值
        Consumer<String> con1 = (String s)->{
            System.out.println(s);
        };
        con1.accept("lambda方法");
    }
}

数据类型可以省略，因为可以由编译器推断出（编译推断）

注意和上面有点区别

public class lambdaTest2 {
    @Test
    public void test(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("传统方法");

        // lambda 表达式方法，需要一个参数，无返回值
        // (类型推断版本)
        Consumer<String> con1 = (s)->{
            System.out.println(s);
        };
        con1.accept("lambda方法");
    }
}

lambda若只需要一个参数，参数的小括号可以省略

public class lambdaTest2 {
    @Test
    public void test() {
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("传统方法");

        // lambda 表达式方法，需要一个参数，无返回值
        // (类型推断版本)
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("lambda方法(类型推断)");
        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("lambda方法 省略括号");
    }
}

lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

Comparator<Integer> con3 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }// 传统方式
        };
        Comparator<Integer> con4 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }; // lambda表达式

当lambda 体只有一条语句时，return 与{}若有，可以省略

 Comparator<Integer> con5 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            } // 传统方式
        };
        //  当lambda 体只有一条语句时，return 与{}若有，可以省略
        Comparator<Integer> con6 = (o1, o2) -> o1.compareTo(o2);
    }

总结

-> ：lambda操作符或者箭头操作符
-> 左边：lambda形参列表 (其实就是接口中的抽象方法的形参列表)
-> 右边：lambda体 （其实就是重写的抽象方法的方法体）

-> 左边：可以省略数据类型（数据推断），如果只有一个形参，可以省略（）
-> 右边：如果只有一条语句，可以省略{}和return

函数式接口

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
有注解@FunctionalIntetrface
如
Runable，Comparator

当然我们也可以自己定义函数式接口