java学习笔记（9）——Lambda 表达式

函数式编程

尽量忽略面向对象的复杂语法，强调做什么，而不是以什么形式来做（抛开面向对象形式）

public class DemoLambda {
    public static void main(String[] args) {
        //常规定义
//        RunnableImpl rn = new RunnableImpl();
//        Thread t = new Thread(rn);
//        t.start();
        //匿名内部类
//        Runnable r = new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName() + "新线程已经创建");
//            }
//        };
//        new Thread(r).start();

        //简化代码
        new Thread(new Runnable() {
            @Override
            public void run() {
            //方法体
                System.out.println(Thread.currentThread().getName() + "新线程已经创建");
            }
        }).start();
    }
}

只有方法体才是关键所在
真正希望是将run方法体内的代码，传递给Thread类知晓
创建对象时为了完成这个任务而不得不为之

Lambda表达式

删除选中部分，即为Lambda表达式

        new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "212");
            }
        ).start();

()对应run方法的参数

此处的大括号就是重写run方法的部分

代码分析：

1. ()对应run方法的参数，有则写，无则空
2. -> 代表将前面的参数传递给后面的代码
3. 方法体为最终目的代码

Lambda标准格式

• 一些参数
• 一个箭头
• 一段代码

(参数类型 参数名称) -> { 代码语句（一些重写方法的代码） }

()：接口中抽象方法的参数列表
->：传递，将参数传递给方法体{}
{}:重写接口的抽象方法的方法体

有参案例

有参无返回

public class TestMain {
    public static void main(String[] args) {
        Person[] arr = {
                new Person("万", 33),
                new Person("继", 23),
                new Person("宣", 24),
        };

//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });

        //Lambda
        Arrays.sort(arr, (Person o1, Person o2) -> {
            return o1.getAge() - o2.getAge();
        });

        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

output：
Person{name='继', age=23}
Person{name='宣', age=24}
Person{name='万', age=33}

有参有返回

public class Test2Main {

    private static void invokeCalc(int a, int b, Calculator calculator) {
        int result = calculator.calc(a, b);
        System.out.println("计算结果为： " + result);
    }

    public static void main(String[] args) {
//        invokeCalc(120, 130, new Calculator() {
//            @Override
//            public int calc(int a, int b) {
//                return a + b;
//            }
//        });
        
                invokeCalc(120, 130, (int a, int b) -> {
            return a + b;
        });
    }
}

Lambda表达式： 可推导、可省略
凡是根据上下文推导出来的内容，都可以省略书写

可以省略的内容：！！！！！

1. （参数列表）：参数列表的数据类型可以省略
2. （参数列表）：括号中参数只有一个，类型和()都可以省略
3. { 一些代码 }：代码只有一行下，无论是否有返回值，都可以省略 {} return ; （必须一起省略）

这里面的return简化后省去，一定得注意

Lambda使用条件：

1. Lambda必须具有接口，并且接口中仅有一个抽象方法
2. 必须具有上下文推断：方法的参数或者局部变量类型必须为Lambda对应的接口类型