Lambda表达式

冗余的匿名内部类

匿名内部类有很多地方是冗余的。

比如在使用匿名内部类完成多线程代码中。
因为Thread构造方法中需要传递一个Runnable类型的参数，所以我们不得不写了new Runnable
因为匿名内部类中要重写方法，所以我们又不得不写了run方法的声明部分(public void run)

在整个匿名内部类中最重要的是方法的前中后三点。
    前：方法参数
    中：方法体
    后：返回值。

匿名内部类中很多东西都冗余，最好的情况是只关注最关键的东西，也就是只关注匿名内部类中方法的参数，方法体，返回值。

如果使用Lambda表达式，可以只关注最核心的内容，可以解决匿名内部类的冗余
Lambda是匿名内部类的简化写法

Lambda表达式使用的是函数式编程思想

面向对象思想：怎么做。
函数式编程思想：做什么

public class Demo01Inner {
    public static void main(String[] args) {
        //使用匿名内部类的方式完成多线程。
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行了");
            }
        }).start();

        //Lambda表达式初体验
        new Thread(() -> System.out.println(Thread.currentThread().getName()  + "执行了")).start();
    }
}

Lambda表达式标准格式

匿名内部类的格式:
new 父类或接口(){
重写方法
}

匿名内部类中很多东西都是冗余的，在匿名内部类中核心的东西是方法的参数，方法体，返回值，最好的情况只关注这三点。
使用Lambda表达式可以让我们只关注方法参数，方法体，返回值这三个内容。
Lambda标准格式:
(参数类型 参数名 )->{
方法体;
return 返回值;
}
格式解释:
1. 小括号中的参数和之前传统方法参数写法一样，如果有多个参数，使用逗号隔开。
2. ->是一个运算符，表示指向性动作。
3. 大括号中的内容之前传统方法大括号中的内容写法一样的。
Lambda表达式可以省去面向对象中的条条框框，让我们只关注最核心的内容。
Lambda表达式是函数式编程思想，函数式编程思想中，可推导，就是可省略。

因为在Thread的构造方法中需要传递Runnable接口类型的参数，所以可以省略new Runnable。
因为Runnable中只有一个抽象方法叫做run，所以在重写该方法时可以省略public void run

public class Demo02Lambda {
    public static void main(String[] args) {
        //使用匿名内部类完成多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行了");
            }
        }).start();

        //使用Lambda表达式完成多线程
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "执行了");
        }).start();
    }
}

Lambda表达式比较器排序

/*
    使用比较器排序对集合中的Person对象按照年龄从小到大的顺序排序
 */
public class Demo03Collections {
    public static void main(String[] args) {
        //创建集合
        List<Person> list = new ArrayList<>();
        //添加Person对象
        list.add(new Person("jack", 20));
        list.add(new Person("rose", 18));
        list.add(new Person("tony", 22));
        //使用比较器排序（对集合中的Person对象按照年龄从小到大的顺序排序）
        //单独定义Comparator实现类，然后创建实现类对象。
        //Collections.sort(list, new Rule());

        //使用匿名内部类完成比较器排序
        /*
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        */

        /*
            (参数类型 参数名) -> {
                方法体;
                return 返回值;
            }
         */
        //使用Lambda表达式完成比较器排序
        /*
        Collections.sort(list, (Person o1, Person o2) -> {
            return o1.getAge() - o2.getAge();
        });
        */

        //使用Lambda表达式省略格式完成比较器排序
        Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());


        //输出结果
        System.out.println(list);
    }
}
public class Person {
    private String name;
    private int age;

    //get...set...构造方法...toString()
}
public class Rule implements Comparator<Person>{
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }
}

Lambda表达式简化写法

Lambda标准格式：
(参数类型 参数名) -> {
方法体;
return 返回值;
}

****省略规则：****
    1. 小括号中的参数类型可以省略。
    2. 如果小括号中只有一个参数，那么可以省略小括号。
    3. 如果大括号中只有一条语句，那么可以省略大括号，return，以及分号。

public class Demo04SimpleLambda {
    public static void main(String[] args) {
        //使用Lambda标准格式完成多线程
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "执行了");
        }).start();
        //使用Lambda表达式省略格式完成多线程
        new Thread(() -> System.out.println(Thread.currentThread().getName() + "执行了")).start();
    }
}

Lambda表达式使用前提

Lambda表达式的使用前提
1. 必须要有接口（不能是抽象类），接口中有且仅有一个需要被重写的抽象方法。（比如Runnable或Comparator）
2. 必须支持上下文推导。 要能够推导出来Lambda表达式表示的是哪个接口中的哪个方法。
最常用的上下文推导的方式是使用函数式接口当做方法参数，然后传递Lambda表达式。

**注意：**
    如果一个接口中有且仅有一个需要被重写的抽象方法，那么该接口也叫做函数式接口。

public class Demo05BeforeLambda {
    public static void main(String[] args) {
        //() -> System.out.println(Thread.currentThread().getName() + "执行了");

        //因为Thread构造方法需要传递Runnable接口类型的参数，而Runnable接口中只有一个需要被重写的抽象方法叫做run
        //所以向Thread构造方法位置传递的Lambda表示必然表示Runnable接口中的run方法。
        new Thread(() -> System.out.println(Thread.currentThread().getName() + "执行了")).start();
    }
}