初步认识Lambda表达式

转自B站波哥视频

Lambda 是一个匿名函数，可以把 Lambda表达式 理解为是一段可以传递的代码 。可以写出更简洁、更灵活的代码。但如果不熟练，会大大降低代码的可读性，需谨慎使用

目录

1.需求分析

2.Lambda表达式初体验

3.Lambda的语法规则

3.1 Lambda练习1

3.2 Lambda练习2

4. @Functionallnterface注解

5. Lambda表达式的原理

6.Lambda表达式的省略式写法

7.Lambda表达式的使用前提

8.Lambda和匿名内部类的对比

---

1.需求分析

创建一个新的线程，指定线程要执行的任务

public static void main(String[] args) {
        //开启新线程
        new Thread(new Runnable() {
            public void run() {
                System.out.println("新线程执行的代码："+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("主线程中的代码："+Thread.currentThread().getName());
    }

代码分析

1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心

2. 为了执行run方法体，不得不需要Runnable的实现类

3. 为了省去定义一个Runnable的实现类，不得不使用匿名类

4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错

5. 而实际上，我们只在乎方法体中的代码

2.Lambda表达式初体验

可能出现的报错设置

1.将语言级别设置为lambda表达式

2.编译出错 java: Compilation failed: internal java compiler error（java:编译失败：内部java编译器错误） 解决方法：设置相应Module的target bytecode version的合适版本（跟你jkd版本一致就行）

Lambda表达式是一个匿名函数，可以理解为一段可传递的代码

new Thread(() -> {
            System.out.println("新线程Lambda表达式"+Thread.currentThread().getName());
        }).start();

Lambda表达式的优点：简化了匿名内部类的使用，语法更简单 匿名内部类语法冗余，体验Lambda表达式后，发现Lambda表达式是简化匿名内部类的一种方式。

3.Lambda的语法规则

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

(参数类型 参数名称) -> {
    
}

格式说明：

• (参数类型 参数名称)：参数列表

• {代码体}：方法体

• ->：分割参数列表和方法体

3.1 Lambda练习1

练习无参、无返回值的Lambda

1.定义一个接口

public interface UserService {
    void show();
}

2.然后创建主方法使用

public class Demo03Lambda {
    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("执行了show方法---------");
            }
        });
        //使用Lambda表达式，无参数
        goShow(() -> {
            System.out.println("Lambda表达式执行show方法---------------------");
        });
    }
​
    public static void goShow(UserService userService){
        userService.show();
    }
}

3.输出

执行了show方法--------- Lambda
表达式执行show方法---------------------

3.2 Lambda练习2

1.创建一个实体类Person对象

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private Integer age;
    private Integer height;
}

2.在list集合中保存多个Person对象，非Lambda表达式输出list集合数据

public class Demo04Lambda {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person("张三",18,180));
        list.add(new Person("王五",38,172));
        list.add(new Person("李四",28,168));
​
        //指定一个排序规则
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        for (Person person : list) {
            System.out.println(person);
        }
        System.out.println("\n");
    }
}

3.我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类，且执行的方法有参数和返回值，那么我们可以改写为Lambda表达式

Collections.sort(list,(Person o1, Person o2) -> {
            return o1.getHeight() - o2.getHeight();
        });
        for (Person person : list) {
            System.out.println(person);
        }

4.输出结果

Person(name=李四, age=28, height=168) 
Person(name=王五, age=38, height=172) 
Person(name=张三, age=18, height=180)

4. @Functionallnterface注解

如果接口有这个注解，声明多个方法时，注解会报错。把多余的方法删除，注解恢复正常

/**
* 这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法
*/
@Functionallnterface
public interface UserService{
    void show();
}

5. Lambda表达式的原理

匿名内部类的本质是在编译时生成一个class文件，xxx$1.class

public class Demo01Lambda {
    public static void main(String[] args) {
        //开启新线程
        new Thread(new Runnable() {
            public void run() {
                System.out.println("新线程执行的代码："+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("主线程中的代码："+Thread.currentThread().getName());
        System.out.println("---------------------------------------");
        //使用Lambda表达式
        new Thread(() -> {
            System.out.println("新线程Lambda表达式"+Thread.currentThread().getName());
        }).start();
    }
}

还可以通过反编译工具来查看生成的代码，XJad工具来查看。也可以查看编译后的代码

static class Demo01Lambda$1
    implements Runnable
{
    public void run()
    {
        System.out.plintln((new StringBuilder()).append("新线程中执行的代码："
).append(Thread.currentThread().getName()).toString);
    }    
    
    Demo01Lambda$1()
    {
        
    }
}    

那么Lambda表达式的原理我们也可以用反编译工具查看

写的有Lambda表达式的class文件，我们通过XJad查看报错。这时我们可以通过JDK自带的一个工具：javap对字节码进行反编译汇编操作

javap -c -p 文件名.class
    
-c：表示对代码进行反编译
-p：显示所有的类和成员    

反汇编的结果：

D:\project\test\JDK8Demo\target\classes\com\jdk\lambda>javap -c -p Demo03Lambda$1.class
Compiled from "Demo03Lambda.java"
final class com.jdk.lambda.Demo03Lambda$1 implements com.jdk.service.UserService {
  com.jdk.lambda.Demo03Lambda$1();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void show();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String 执行了show方法---------
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

在这个反编译的源码中我们看到了一个静态方法 lambda$main$0()，这个方法做了什么事情呢，我们可以通过debug的方式来查看

上面的效果可以理解为

public class Demo03Lambda {
    public static void main(String[] args) {
        ......
    }
​
    public static void lambda$main$0(){
        System.out.println("Lambda方法执行了...");
    }
}

为了更加直观的理解这个内容，我们可以在运行的时候添加 -Djdk.internal.lambda.dumpProxyClasses，加上这个参数会将内部calss码输出到一个文件中

-Djdk.internal.lambda.dumpProxyClasses 要运行的包名，类名

这个时候文件夹会生成一个新的class文件

通过反编译该文件得到以下代码，可以看到重写了show方法，调用了静态方法

// $FF: synthetic class
final class Demo03Lambda$$Lambda$1 implements UserService {
    private Demo03Lambda$$Lambda$1() {
    }
​
    @Hidden
    public void show() {
        Demo03Lambda.lambda$main$0();
    }
}

可以看到这个匿名的内部类实现了UserService接口，并重写了show()方法，在show()方法中调用了Demo03Lambda.lambda$main$0()，也就是调用了Lambda中的内容。

public class Demo03Lambda {
    public static void main(String[] args) {
       goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("执行了show方法---------");
            }
        });
    }
​
    public static void goShow(UserService userService){
        userService.show();
    }
    public static void lambda$main$(){
        System.out.println("Lambda执行了...");;
    }
}

小结：

• 匿名内部类在编译的时候会产生一个class文件。

• Lambda表达式在程序运行时会形成一个类。

  1. 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码

  2. 还会形成一个匿名内部类，实现接口，重写抽象方法

  3. 在接口中重写方法会调用新生成的方法

6.Lambda表达式的省略式写法

在Lambda表达式的标准写法基础上，可以使用省略写法的规则为：

1. 小括号内的参数可以省略

2. 如果小括号内有且只有一个参数，则小括号可以省略

3. 如果大括号内有且只有一条语句，可以同时省略大括号、return关键字及语句分号

public class Demo05Lambda {
    public static void main(String[] args) {
        goShow1((String name, int age)->{
            return name+age+"----------";
        });
        //省略写法
        goShow1((name,age)->
            //只有一条语句，可以省略大括号和return关键字，但是";"也要去掉
            name+age+"99999"
        );
​
        goShow2((String name)->{
            return 8888;
        });
        //省略写法
        goShow2(name->{
            //只有一个参数时，可以省略小括号
            System.out.println("省略写法");
            return 4444;
        });
    }
​
    public static void goShow1(Student1Service service1){
        service1.show("张三",88);
    }
    public static void goShow2(Student2Service service2){
        service2.show("张三");
    }
}

7.Lambda表达式的使用前提

Lambda表达式的语法式非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意：

1. 方法的参数或局部变量类型必须为接口才能使用Lambda

2. 接口中有且只有一个抽象方法（@FunctionalInterface）

8.Lambda和匿名内部类的对比

Lambda和匿名内部类的对比

1.所需类型不一样

1. 匿名内部类的类型可以是类、抽象类、接口

2. Lambda表达式需要的类型必须是接口

2.抽象方法的数量不一样

1. 匿名内部类所需的接口中的抽象方法的数量是随意的

2. Lambda表达式所需的接口中只能有一个抽象方法，即函数式接口

3.实现原理不一样

1. 匿名内部类是在编译后形成一个class

2. Lambda表达式是在程序运行的时候动态生成class