Java 8 lambda表达式及方法引用实现原理

lambda表达式不仅使编码简洁,而且可读性也大大提升。真的很佩服设计这个功能的Oracle工程师。
在佩服之余,不禁思考这个功能的实现原理是什么?
带着这个疑问,从网上查阅资料,发现了下面这篇文章,

https://www.cnblogs.com/WJ5888/p/4667086.html

这篇文章详细介绍了探究lambda表达式的实现原理的过程,读完之后很受启发,于是我使用文章中的方法进一步探究方法引用的实现原理。
本文接下来分为两个部分,第一部分主要介绍lambda表达式的实现原理,第二部分主要介绍方法引用的实现原理。

一、lambda表达式实现原理

这一小节主要是对网上关于lambda表达式的原理做一下总结,如果想了解更细的资料,可以查阅上面提到的那篇文章。
JVM在处理lambda表达式时,在内部自动生成了一个方法和内部类,通过内部类和方法的调用实现了lambda表达式的功能。

1、静态方法里面使用lambda表达式

比如下面这个例子:

public class Main {
    public String sayHello(Function<String,String> f){
        return f.apply("aa");
    }
    public static void main(String argv[]){
        Main main=new Main();
        System.out.println(main.sayHello(x->("start "+x+" end")));
    }
}

运行上述代码前,需要加上-Djdk.internal.lambda.dumpProxyClasses启动参数,这样可以将自动生成的内部类输出到文件。上面这个代码产生的内部类为Main$$Lambda$1.class,通过反编译工具看到如下源码:

import java.lang.invoke.LambdaForm.Hidden;
import java.util.function.Function;

// $FF: synthetic class
final class Main$$Lambda$1 implements Function {
    private Main$$Lambda$1() {}

    @Hidden
    public Object apply(Object var1) {
        return Main.lambda$main$0((String)var1);
    }
}

自动生成的内部类的构造方法为私有,因此只有Main类里面可以创建对象,而且该类实现了接口Function。apply方法里面调用了Main.lambda$main$0()方法,这个方法也是JVM自动生成的,该方法位于Main类里面,通过javap -p命令可以看到该方法的定义:

private static java.lang.String lambda$main$0(java.lang.String);

这个方法也是私有的,而且还是静态方法,根据推测,lambda表达式的逻辑应该是在lambda$main$0方法里面实现的。
据此,可以知道使用了lambda表达式的Main类等价于:

public class Main {
	//自动生成内部类
    final class Main$$Lambda$1 implements Function {
        private Main$$Lambda$1() {
        }
        public Object apply(Object var1) {
            return Main.lambda$main$0((String)var1);
        }
    }
    //自动生成静态方法
    private static java.lang.String lambda$main$0(java.lang.String var){
        //lambda表达式的逻辑
        return "start "+var+" end";
    }
    public String sayHello(Function<String,String> f){
        return f.apply("aa");
    }
    public static void main(String argv[]){
        Main main=new Main();
        System.out.println(main.sayHello(main.new Main$$Lambda$1()));
    }
}

上面这个例子的lambda表达式位于static方法里面,如果lambda表达式是在实例方法里面,那么创建的内部类和方法会有什么不一样吗?

2、实例方法里面使用lambda表达式

看一下下面这个例子:

public class Main {
    public String sayHello(Function<String,String> f){
        return f.apply("aa");
    }
    public static void main(String argv[]){
        Main main=new Main();
        main.process();
    }
    //lambda表达式位于实例方法process里面
    public void process(){
        System.out.println(sayHello(x->{
            return "start "+x+" end";
        }));
    }
}

运行上面的代码之后,生成的内部类为:

final class Main$$Lambda$1 implements Function {
    private final Main arg$1;
    private Main$$Lambda$1(Main var1) {
        this.arg$1 = var1;
    }
    private static Function get$Lambda(Main var0) {
        return new Main$$Lambda$1(var0);
    }
    @Hidden
    public Object apply(Object var1) {
        return this.arg$1.lambda$process$0((String)var1);
    }
}

通过比较两个场景下的内部类,发现两者之间还是有一些不同:

  • apply()方法里面,调用的是Main对象的实例方法,不再是静态方法;
  • 新增了一个私有静态方法get$Lambda();
  • 新增了一个类为Main的私有属性,通过构造方法初始化该属性值。

接着通过java -p命令可以得到自动生成的方法为:

 private java.lang.String lambda$process$0(java.lang.String);

发现该方法也不再是静态的了。根据前面的经验,我们可以推测在实例方法里面使用lambda表达式的Main类等价于:

public class Main {
    static final class Main$$Lambda$1 implements Function {
        private final Main arg$1;

        private Main$$Lambda$1(Main var1) {
            this.arg$1 = var1;
        }

        private static Function get$Lambda(Main var0) {
            return new Main$$Lambda$1(var0);
        }

        public Object apply(Object var1) {
            return this.arg$1.lambda$process$0((String)var1);
        }
    }

    private java.lang.String lambda$process$0(java.lang.String var){
        return "start "+var+" end";
    }

    public String sayHello(Function<String,String> f){
        return f.apply("aa");
    }
    public static void main(String argv[]){
        Main main=new Main();
        main.process();
    }
    
    public void process(){
        System.out.println(sayHello(Main$$Lambda$1.get$Lambda(this)));
    }
}

到这里,lambda表达式的两个场景都介绍完了。
看到上面的等价代码,产生一个疑问,为什么要在类Main里面自动生成一个方法?完全可以将lambda表达式的逻辑放到内部类的apply方法里面,一样可以实现功能。以上面代码为例,可以将apply方法修改如下:

	final class Main$$Lambda$1 implements Function {
        private final Main arg$1;

        private Main$$Lambda$1(Main var1) {
            this.arg$1 = var1;
        }

        private static Function get$Lambda(Main var0) {
            return new Main$$Lambda$1(var0);
        }
		//lambda表达式直接放到apply方法里面
        public Object apply(Object var1) {
            return "start "+var1+" end";
        }
    }

按照上面方式生成内部类,类Main里面就不需要lambda$process$0方法了。思考了一下这个问题,我认为之所以类Main再多生成一个方法的原因是,如果将lambda表达式的逻辑放到apply里面,某些情况下运行时会产生一些很奇怪的现象。比如在lambda表达式里面使用this关键字,还是以上面的Main类为例,将process方法修改如下:

		sayHello(x->{
            System.out.println(this);
            return "start "+x+" end";
        });

从开发者的角度看,this关键字代表的是Main对象,而如果将lambda表达式的逻辑放到apply方法里面,那么实际运行时,this关键字成了Main$$Lambda$1对象。开发人员明明没有写过这个类啊,怎么突然出现一个这个类,这会给开发人员使用带来困扰。
这说的是自动生成的实例方法,自动生成的静态方法也是一样,在lambda表达式里面可以调用Main类的其他静态方法,如果没有这个自动生成的静态方法,那么调用Main类的其他静态方法编译就会报错。

二、方法引用实现原理

本小节主要介绍引用实例方法和引用某个类的任意实例方法的原理。

1、引用实例方法原理

先来看一下引用实例方法的代码。

public class Main {
    public void sayHello(Consumer<String> f){
         f.accept("aa");
    }
    public static void main(String argv[]){
        Main main=new Main();
        main.sayHello(System.out::print);
    }
}

上面代码直接引用了PrintStream对象的print()方法。运行上面代码后,JVM自动创建类Main$$Lambda$1:

final class Main$$Lambda$1 implements Consumer {
    private final PrintStream arg$1;

    private Main$$Lambda$1(PrintStream var1) {
        this.arg$1 = var1;
    }

    private static Consumer get$Lambda(PrintStream var0) {
        return new Main$$Lambda$1(var0);
    }

    @Hidden
    public void accept(Object var1) {
        this.arg$1.print((String)var1);
    }
}

在Main$$Lambda$1.accept()方法中直接调用了PrintStream对象的print()方法,这与lambda表达式生成的的内部类不同。因此可以猜测Main类里面不会像lambda表达式那样自动新增方法,通过javap -p命令也验证了这个猜测。
对于方法引用,JVM只生成了一个内部类。
可以推测对于上面这个例子Main类等价于:

public class Main {
    static final class Main$$Lambda$1 implements Consumer {
        private final PrintStream arg$1;

        private Main$$Lambda$1(PrintStream var1) {
            this.arg$1 = var1;
        }

        private static Consumer get$Lambda(PrintStream var0) {
            return new Main$$Lambda$1(var0);
        }

        public void accept(Object var1) {
            this.arg$1.print((String)var1);
        }
    }

    public void sayHello(Consumer<String> f){
         f.accept("aa");
    }
    public static void main(String argv[]){ 
        Main main=new Main();
        main.sayHello(Main$$Lambda$1.get$Lambda(System.out));
    }
}

2、引用某个类的任意实例方法原理

下面的代码可以对流中的字符串排序,在sorted方法中引用了String的任意实例方法。

public class Main {
    public static void main(String argv[]){
        Stream<String> sortedList= Stream.of("a","b","c");
        sortedList.sorted(String::compareTo);
    }
}

运行上面代码后,JVM自动生成类Main$$Lambda$1:

final class Main$$Lambda$1 implements Comparator {
    private Main$$Lambda$1() {}

    @Hidden
    public int compare(Object var1, Object var2) {
        return ((String)var1).compareTo((String)var2);
    }
}

在compare方法里面通过调用String对象的compareTo()方法完成字符串的比较。
在Main类中被引用的方法是一个入参,而compare方法是两个入参,大家在引用类的任意实例方法时注意这个不同。
类Main的等价代码与上一小节类似,这里不再展示。

已标记关键词 清除标记
相关推荐
<p> JDK8已经发行有几年了,在该版本中推出了不少新特性,其中比较有代表的新特性有:Lambda表达式,Stream流,方法引用。在网上也有很多关于这些新特性的介绍,但个人觉得网上的很多文字对新特性的介绍是不够全面的,而且不够通俗易懂,对于初学者不太好理解和掌握。特别是方法引用这个新特性,讲解得晦涩难懂。 </p> <p>         为了让更多的Java从业者在学习新特性的时候少走弯路并快速掌握新特性的使用,本课程将详细讲解Lambda表达式,Stream以及方法引用等非常核心的新特性,相信学完该课程你可以在开发中灵活运行这些新特性语法编写出效率高且优雅的代码,从此让你的同事甚至你的项目经理刮目相看。本课程的内容包括如下知识点: </p> <ol><li> <p> Lambda表达式概述和体验 </p> </li> <li> <p> Lambda表达式标准格式 </p> </li> <li> <p> Lambda表达式使用条件 </p> </li> <li> <p> Lambda表达式实现原理 </p> </li> <li> <p> Lambda表达式作为方法参数 </p> </li> <li> <p> Lambda表达式作为方法返回值 </p> </li> <li> <p> Lambda表达式省略格式 </p> </li> <li> <p> Stream流概述和体验 </p> </li> <li> <p> Stream流常用方法:forEach/filter/limit/skip/map/count/collect/concat/parall/parallStream </p> </li> <li> <p> Stream流使用注意事项 </p> </li> <li> <p> Stream流结果收集 </p> </li> <li> <p> 并发流和串行流 </p> </li> <li> <p> 方法引用概述和体验 </p> </li> <li> <p> 静态方法引用 </p> </li> <li> <p> 对象方法引用 </p> </li> <li> <p> 构造方法引用 </p> </li> <li> <p> 特定对象实例方法引用 </p> </li> </ol>
©️2020 CSDN 皮肤主题: 像素格子 设计师:CSDN官方博客 返回首页