Lambda表达式第四版

1、冗余的Runnbale代码

package com.lambda;

public class Demo01Runnable {

    public static void main(String[] args) {

        RunnableImpl runnable = new RunnableImpl();

        Thread thread = new Thread(runnable);

        thread.start();//Lambda表达式

    }
}

class RunnableImpl implements Runnable {

    @Override
    public void run() {
        System.out.println("Lambda表达式");
    }
}

package com.lambda;

public class Demo01Runnable {

    public static void main(String[] args) {

//        Runnable r = () -> System.out.println("Lambda表达式");

//        new Thread(r).start();


//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("Lambda表达式");
//            }
//        }).start();

        new Thread(() -> System.out.println("Lambda表达式")).start();//Lambda表达式

    }
}

2、匿名内部类的好处与弊端

1. 一方面，匿名内部类可以帮我们省去实现类的定义
2. 另一方面，匿名内部类的语法——确实太复杂！

3、Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

• 一些参数
• 一个箭头
• 一段代码
• 格式：（参数列表）->  {一些重写方法的代码}
• （）：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔
•   ->  ：传递的意思，把参数传递给方法体 { }
•   {}   :  重写接口的抽象方法的方法体

 4、Lambda表达式的无参数无返回值的练习

package com.lambda;

public class Demo1Lambda {

    public static void main(String[] args) {

//        invokeCook(new Cook() {
//            @Override
//            public void makeFood() {
//                System.out.println("吃饭了");
//            }
//        });

        invokeCook(()-> System.out.println("吃饭了"));//吃饭了

    }

    public static void invokeCook(Cook cook) {
        cook.makeFood();
    }
}

interface Cook {

    void makeFood();
}

5、 Lambda表达式有参数有返回值的练习（自定义类）

package com.lambda;


import java.util.Arrays;

public class Demo2Lambda {

    public static void main(String[] args) {

        Person person1 = new Person("小明",23);
        Person person2 = new Person("小红",33);
        Person person3 = new Person("小蓝", 17);

        Person[] arr = {person1, person2, person3};

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

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

        Arrays.sort(arr, (o1, o2) -> o1.getAge() - o2.getAge());

        System.out.println(Arrays.toString(arr));
    }



}

class Person {

    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

6、Lambda表达式有参数有返回值的练习（自定义接口） 

package com.lambda;

public class Demo3Lambda {
    public static void main(String[] args) {

//        invokeCalc(new Calculator() {
//            @Override
//            public int calc(int a, int b) {
//                return a + b;
//            }
//        });

//        invokeCalc((int a, int b) -> {
//                    return a + b;
//                }
//        );
        invokeCalc((a, b) -> a + b);//250
    }

    public static void invokeCalc(Calculator c) {

        int calc = c.calc(120, 130);
        System.out.println(calc);
    }
}

interface Calculator {
    int calc(int a, int b);
}

package com.lambda;

public class Demo4Lambda {

    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;
//        });

        invokeCalc(120, 130, (a, b) -> a + b);//250
    }

    public static void invokeCalc(int a, int b, Calculator c) {
        int sum = c.calc(a, b);
        System.out.println(sum);
    }
}

interface Calculator {

    int calc(int a, int b);
}

7、Lambda省略格式

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

1. （参数列表）：括号中参数列表的数据类型，可以省略不写
2. （参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
3.   {一些代码}  ：如果{}中的代码只有一行，无论是否有返回值，都可以省略（{ }，return，分号），注意：要省略 { }，return，分号必须一起省略   

8、Lambda的使用前提 

Lambda的语法非常简单，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

1. 使用Lambda必须具有接口，且要求 接口 中有且仅有一个抽象方法。
2. 无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只能当接口中的抽象方法存在且唯一时，才可以使用Lambda
3. 使用Lambda必须具有上下文推断。
4. 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。