JDK8新特性 lambda表达式

1、lambda表达式初识

对于一个多线程的，我们以前都是使用new Thread().start();
在Thread中使用实现Runnable接口来实现

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        }).start();

这个匿名内部类做了以下事情：

1. 定义一个没有名字的类
2. 这个类实现了Runnable接口
3. 创建了这个类的对象。

但其实我们所关注的只有run方法和里面需要执行的代码，其冗余度很高。
为此我们引入了lambda表达式，来简化代码。其体现的式函数式编程思想，只需要将需要执行的代码放入到函数中。
lambda就是一个匿名函数，我们需要将要执行的代码放入到lambda表达式中即可。

        new Thread(()->{
            System.out.println("lambda表达式");
        }).start();

2. lambda的标准格式

一个标准的main函数式这样的

    public static void main(String[] args){

    }

而lambda表达式，作为一个匿名函数，public static void main不需要，其由以下部分组成

1. (参数列表)：参数列表
2. {}：方法体
3. ->：没有实际含义，起到连接的作用

( ) -> {
}

以后我们看到方法的参数是接口就可以考虑使用lambda表达式
lambda表达式就是对接口中的抽象方法的重写。

2.1 无参数无返回值的lambda

image.png

2.2 有参数有返回值的lambda

image.png

3. lambda省略格式

匿名内部类在编译后会形成一个新的类

• 小括号内参数的类型可以省略
• 如果小括号内有且仅有一个参数，则小括号可以省略
• 如果大括号内有且仅有一个语句，可以同时省略大括号、return关键字以及语句分号，必须同时省略

public class Demo3Param {
    public static void main(String[] args){
        ArrayList persons = new ArrayList<>();
        persons.add(new Person("刘德华", 58, 180));
        persons.add(new Person("张学友", 48, 170));
        persons.add(new Person("黎明", 53, 177));
        persons.add(new Person("郭富城", 52, 184));

        // 匿名内部类方式重写排序方法
        Collections.sort(persons, new Comparator() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.age - p2.age;
            }
        });

        // lambda
        Collections.sort(persons, (Person p1, Person p2)->{
            return  p1.age - p2.age;
        });

        persons.forEach((Person p)->{
            System.out.println(p);
        });
    }

    static class Person{
        private String name;
        private int age;
        private int height;

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

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

其lambda表达式

Collections.sort(persons, (Person p1, Person p2)->{
            return  p1.age - p2.age;
        });

可省略

Collections.sort(persons, (p1, p2) ->p1.age - p2.age);

 persons.forEach((Person p)->{
            System.out.println(p);
        });

可省略

 persons.forEach(p-> System.out.println(p));

4.lambda的前提条件

1. 方法的参数或变量的类型是接口
2. 这个接口只能由一个抽象方法

public class Demo4Condition {
    public static void main(String[] args){
        test(()-> System.out.println("1"));
    }
    public static void test(Flyable f){

    }

    @FunctionalInterface  // 检测这个接口是不是只有一个抽象方法。如果超过一个就会报错。
    interface Flyable{
        // 接口中有且仅有一个抽象方法
        // 只有一个抽象方法的接口称为函数式接口，我们就能使用lambda
        public abstract void eat();
//        public abstract void eat2();
    }
}

5. lambda和匿名内部类的对比

1、 所需的类型不一样
匿名内部类，需要的类型可以是类，抽象类，接口
lambda表达式需要的类型必须是接口
2、抽象方法不一样
匿名内部类所需的接口中抽象方法的数量随意
lambda表达式所需的接口只能由一个抽象方法
3、实现原理不同
匿名内部类是在编译后形成的class
lambda表达式是在程序运行的时候动态生成的的class

lambda就是重写了接口中的唯一的一个静态方法，其里面只写了方法参数和方法体，而剪掉了匿名内部类的哪些冗余的内容。
调用的时候，也是一个函数方法，其参数是属于这个接口类型，那么这个参数调用这个接口的那个唯一的静态方法，就是执行lambda的方法内容。