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

最新推荐文章于 2024-05-25 16:18:04 发布

龚厂长

最新推荐文章于 2024-05-25 16:18:04 发布

阅读量1.3k

点赞数 1

分类专栏： java8 文章标签： java 方法引用原理

本文链接：https://blog.csdn.net/weixin_38308374/article/details/112497617

版权

java8 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

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

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

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

文章目录

一、lambda表达式实现原理
- 1、静态方法里面使用lambda表达式
- 2、实例方法里面使用lambda表达式
二、方法引用实现原理
- 1、引用实例方法原理
- 2、引用某个类的任意实例方法原理

一、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的等价代码与上一小节类似，这里不再展示。

龚厂长

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
4
评论
Java 8 lambda表达式及方法引用实现原理

lambda表达式不仅使编码简洁，而且可读性也大大提升。真的很佩服设计这个功能的开发人员。在佩服之余，不禁思考这个功能的实现原理是什么？带着这个疑问，先从网上查阅资料，发现了下面这篇文章，https://www.cnblogs.com/WJ5888/p/4667086.html这篇文章详细介绍了lambda表达式的实现原理，读完之后很受启发，于是我使用文章中的方法进一步探究方法引用的实现原理。本文接下来分为两个部分，第一部分主要介绍lambda表达式的实现原理，第二部分主要介绍方法引用的实现原
复制链接

扫一扫