JDK8之Lambda表达式

﹏ヽ暗。殇╰゛Y 2024-03-25 23:56 85阅读 0赞

## 1、使用Thread创建一个线程 ##

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

public static void main(String[] args) {
        
            // 开启一个新的线程
            new Thread(new Runnable() {
        
                @Override
                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表达式优化创建线程 ##

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

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

Lambda表达式的优点：简化了匿名内部类的使用，语法更加简单。

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

## 3、Lambda的语法规则 ##

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

(参数类型 参数名称) -> {
        
        代码体;
    }

格式说明：

*  (参数类型 参数名称):参数列表
 *  \{代码体;\} :方法体
 *  \-> : 箭头，分割参数列表和方法体

**练习无参无返回值的Lambda**

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

**练习有参有返回值的Lambda**

public class Person {
        
        private String name;
        private Integer age;
        private Integer height;
    }
    
        public static void main(String[] args) {
        
            List<Person> list = new ArrayList<>();
            list.add(new Person("周杰伦",33,175));
            list.add(new Person("刘德华",43,185));
            list.add(new Person("周星驰",38,177));
            list.add(new Person("郭富城",23,170));
    
            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);
            }
        }

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

Collections.sort(list,(Person o1,Person o2) -> {
        
                return o1.getAge() - o2.getAge();
            });

## 4、 @FunctionalInterface注解 ##

@FunctionalInterface是标志注解，被该注解修饰的接口只能声明一个抽象方法

@FunctionalInterface
    public interface UserService {
        
        void show();
    }

被@FunctionalInterface标注的接口就可以使用lambda语法了，而且不用担心接口里边出现好几个方法。

## 5、Lambda表达式的原理 ##

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

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

![在这里插入图片描述][eaab0a619f9e418888d1df3c986cc282.png]通过反反编译工具来查看生成的代码

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

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

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

对下面的代码进行反汇编操作。

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

结果：

E:\ideaworkspace\normalJavaDemo\target\classes\com\andrew\java8>javap -c -p Demo03Lambda.class
    Compiled from "Demo03Lambda.java"
    public class com.andrew.java8.Demo03Lambda {
        
      public com.andrew.java8.Demo03Lambda();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: invokedynamic #2,  0              // InvokeDynamic #0:show:()Lcom/andrew/java8/UserService;
           5: invokestatic  #3                  // Method goShow:(Lcom/andrew/java8/UserService;)V
           8: return
    
      public static void goShow(com.andrew.java8.UserService);
        Code:
           0: aload_0
           1: invokeinterface #4,  1            // InterfaceMethod com/andrew/java8/UserService.show:()V
           6: return
    
      private static void lambda$main$0();
        Code:
           0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
           3: ldc           #6                  // String Lambda show 方法执行了...
           5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
           8: return
    }

在这个反编译的源码中我们看到了一个静态方法 lambda$main$0()，这个方法里面做了什么事情呢？我们通过debug的方式来查看下：  
![在这里插入图片描述][81f81e9cc1634ee1926e0d1c08a59a96.png]  
上面的效果可以理解为如下：

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

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

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

命令执行

E:\ideaworkspace\normalJavaDemo\target\classes>java -Djdk.internal.lambda.dumpProxyClasses com.andrew.java8.Demo03Lambda
    Lambda show 方法执行了...

![在这里插入图片描述][d411960006f44f6c9d52f8ab84a70f4d.png]  
反编译后的内容：

package com.andrew.java8;
    
    import java.lang.invoke.LambdaForm.Hidden;
    
    // $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(() -> {
        
                Demo03Lambda.lambda$main$0();
            });
        }
    
        public static void goShow(UserService userService) {
        
            userService.show();
        }
    
        private static void lambda$main$0();
            System.out.println("Lambda show 方法执行了...");
        }
    }

**小结：**

匿名内部类在编译的时候会产生一个class文件（XXXXX$1.class）。

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

1.  在类中新增了一个方法（lambda$main$0()），这个方法的方法体就是Lambda表达式中的代码
2.  还会形成一个匿名内部类（XXX$Lambda$1），实现接口，重写抽象方法
3.  在重写的方法中会调用新生成的方法（lambda$main$0()）

这里先贴个图，慢慢理解，  
![在这里插入图片描述][60ebc977713a4c7dadbd4c2937028986.png]

## 6、Lambda表达式的省略写法 ##

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

1.  小括号内的参数类型可以省略
2.  如果小括号内有且仅有一个参数，则小括号可以省略
3.  如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。

public static void main(String[] args) {
        
            goStudent((String name,Integer age)->{
        
                return name+age+" 6666 ...";
            });
            // 省略写法
            goStudent((name,age)-> name+age+" 6666 ...");
            System.out.println("------");
            
            goOrder((String name)->{
        
                System.out.println("--->" + name);
                return 666;
            });
            // 省略写法
            goOrder(name -> {
        
                System.out.println("--->" + name);
                return 666;
            });
            goOrder(name ->  666);
        }
    
        public static void goStudent(StudentService studentService){
        
            studentService.show("张三",22);
        }
    
        public static void goOrder(OrderService orderService){
        
            orderService.show("李四");
        }

## 7、Lambda表达式的使用前提 ##

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

1.  方法的参数或局部变量类型必须为接口才能使用Lambda
2.  接口中有且仅有一个抽象方法(@FunctionalInterface)

## 8、Lambda和匿名内部类的对比 ##

Lambda和匿名内部类的对比

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

[eaab0a619f9e418888d1df3c986cc282.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f752084e9c92421fbf6b3af1ed23bae1.png
[81f81e9cc1634ee1926e0d1c08a59a96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c2e4d013df16498f967c2d915c31fa65.png
[d411960006f44f6c9d52f8ab84a70f4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8a643c9844564446969432da3221179c.png
[60ebc977713a4c7dadbd4c2937028986.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/62e7b5dcb5b14b86904bbf8e2b5a994b.png