关于java:java学习笔记9Lambda-表达式

2次阅读

共计 1861 个字符，预计需要花费 5 分钟才能阅读完成。

尽量疏忽面向对象的简单语法，强调做什么，而不是以什么模式来做（抛开面向对象模式）

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 表达式


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

()对应 run 办法的参数

此处的大括号就是重写 run 办法的局部

代码剖析：

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

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

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

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

有参无返回

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 表达式：可推导、可省略
但凡依据上下文推导进去的内容，都能够省略书写

能够省略的内容：！！！！！