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 {@Overridepublic 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<Person>() {
//            @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;}@Overridepublic 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作为该接口的实例。

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