Java8新特性--Lambda表达式

lamdaxu
57 阅读6分钟

一、什么是Lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码 像数据一样进行传递）。可以写出更简洁、更 灵活的代码。作为一种更紧凑的代码风格，使 Java的语言表达能力得到了提升。

Lambda表示式的本质是接口的实例对象

二、Lambda表达式语法

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

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

格式说明：

  • (参数类型 参数名称):参数列表。这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号
  • {代码体;} :可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不返回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回
  • -> : 箭头，分割参数列表和方法体

三、案例演示

1、案例一：无参数无返回值

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 方法执行了...");
            }
        });
        System.out.println("----------");
        goShow(() -> { System.out.println("Lambda show 方法执行了..."); });
    }
​
    public static void goShow(UserService userService){
        userService.show();
    }
}

输出结果如下：

show 方法执行了... 
---------- 
Lambda show 方法执行了...

2、案例二：有参有返回值

1、创建一个Persion类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    private String name;

    private Integer age;

    private Integer height;

}

2、然后我们在List集合中保存多个Person对象，然后对这些对象做根据age排序操作

    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);
        }
    }

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

    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,(Person o1,Person o2) -> {
            return o1.getAge() - o2.getAge();
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }

输出结果:

Person(name=郭富城, age=23, height=170)
Person(name=周杰伦, age=33, height=175)
Person(name=周星驰, age=38, height=177)
Person(name=刘德华, age=43, height=185)

3、案例三：创建线程

1、创建一个线程

 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表达式实现

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

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

四、@FunctionalInterface注解

现在思考一个问题，在案例一当中，我们目前只有一个show()方法，现在我增加一个show2()方法。我们是否还能使用Lambda的表达式编写

public interface UserService {
    void show();
    
    void show2();
}

这里需要值得注意，当一个接口当中有两个抽象方法，此时是不能使用Lambda表达式的方式来编写代码的。Lambda表达式支持的编码方式，接口当中只能有一个抽象方法，因此我们编写接口的时候，如果想要这个接口支持Lambda表达式的编码，需要给这个注解增加要给@FunctionalInterface注解。

使用这个注解之后，如果接口中的抽象方法超过一个，编译不通过

五、Lambda表达式省略写法

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

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

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

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

public class Demo05Lambda {

    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("李四");
    }
    
}

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

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

六、Lambda表达式和匿名内部类的区别

1.所需类型不一样

  • 匿名内部类的类型可以是 类，抽象类，接口
  • Lambda表达式需要的类型必须是接口

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

  • 匿名内部类所需的接口中的抽象方法的数量是随意的
  • Lambda表达式所需的接口中只能有一个抽象方法

3.实现原理不一样

  • 匿名内部类是在编译后形成一个class
  • Lambda表达式是在程序运行的时候动态生成class

七、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());
        System.out.println("---------------");
        /*new Thread(() -> { System.out.println("新线程Lambda表达式..." +Thread.currentThread().getName()); })
                .start();*/
    }
}

image.png

那么Lambda表达式的原理是什么呢？我们也通过反编译工具来查看

image.png

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

javap -c -p 文件名.class 

​ -c:表示对代码进行反汇编 
-p:显示所有的类和成员

反汇编的结果：

E:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes\com\bobo\jdk\lambda>javap -c -p Demo03Lambda.class
Compiled from "Demo03Lambda.java"
public class com.bobo.jdk.lambda.Demo03Lambda {
  public com.bobo.jdk.lambda.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/bobo/jdk/lambda/service/UserService;
       5: invokestatic  #3                  // Method goShow:(Lcom/bobo/jdk/lambda/service/UserService;)V
       8: return
​
  public static void goShow(com.bobo.jdk.lambda.service.UserService);
    Code:
       0: aload_0
       1: invokeinterface #4,  1            // InterfaceMethod com/bobo/jdk/lambda/service/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
}

在这个反编译的源码中我们看到了一个静态方法 lambdamainmain0()，这个方法里面做了什么事情呢？我们通过debug的方式来查看下：

image.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:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes>java -Djdk.internal.lambda.dumpProxyClasses com.bobo.jdk.lambda.Demo03Lambda 


Lambda show 方法执行了...

image.png

反编译后的内容：

0转存失败，建议直接上传图片文件

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

public class Demo03Lambda {

    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                Demo03Lambda.lambda$main$0();
            }
        });
        System.out.println("----------");
       
    }

    public static void goShow(UserService userService){
        userService.show();
    }

    private static void lambda$main$0();
        System.out.println("Lambda show 方法执行了...");
    }
}

小结：

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

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

  1. 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
  2. 还会形成一个匿名内部类，实现接口，重写抽象方法
  3. 在接口中重写方法会调用新生成的方法
avatar
文章
阅读
粉丝