Lambda表达式和等效的匿名类

编程问答 2022-06-11

问题描述

如果我有一个采用单方法接口作为参数的方法，我可以这样称呼它：

foo(new Bar() {
    @Override
    public String baz(String qux) {
        return modify(qux) + transmogrify(qux);
    }
}

但是如果我必须在一个紧密的循环中调用foo数百万次，我可能希望避免每次通过循环创建一个匿名类的新实例：

final Bar bar = new Bar() {
        @Override
        public String baz(String qux) {
            return modify(qux) + transmogrify(qux);
        }
    };

while (...) {
    foo(bar);
}

现在，如果我用lambda表达式替换匿名类：

while (...) {
    foo(qux -> modify(qux) + transmogrify(qux));
}

此lambda表达式是否等于上述匿名类示例的第一个或第二个片段？

解决方法

我认为它更像是第二个，因为lambda只会创建Bar的一个实例。

我编写了一个Test类：

public class LambdaTest {
    //create a new runnable for each loop
    void test1(){
        while (true){
            invoke(new Runnable() {
                @Override
                public void run() {
                    System.out.println("---");
                }
            });
        }
    }

    //create only one Runnable
    void test2(){
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("---");
            }
        };
        while (true){
            invoke(runnable);
        }
    }

    //use lambda
    void test3(){
        while (true){
            invoke(()->{
                System.out.println("---");
            });
        }
    }
    private void invoke(Runnable runnable){
    }
}

这是每种方法的字节码：

test1:
         0: aload_0
         1: new           #2                  // class LambdaTest$1
         4: dup
         5: aload_0
         6: invokespecial #3                  // Method LambdaTest$1."<init>":(LLambdaTest;)V
         9: invokevirtual #4                  // Method invoke:(Ljava/lang/Runnable;)V
        12: goto          0

test2:
         0: new           #5                  // class LambdaTest$2
         3: dup
         4: aload_0
         5: invokespecial #6                  // Method LambdaTest$2."<init>":(LLambdaTest;)V
         8: astore_1
         9: aload_0
        10: aload_1
        11: invokevirtual #4                  // Method invoke:(Ljava/lang/Runnable;)V
        14: goto          9

test3:
         0: aload_0
         1: invokedynamic #7,0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
         6: invokevirtual #4                  // Method invoke:(Ljava/lang/Runnable;)V
         9: goto          0

在test1中，每个循环将创建一个匿名类的新实例并调用init方法。
在test2中，将只有一个匿名类实例，并且在循环中具有最少的操作码。
在test3中，test2之间的唯一区别是在循环中的invokedynamic操作码之前添加了invokevirtual。

根据此article，invokedynamic，将调用bootstrap方法来首次创建匿名类的实例，此后，它将在剩余的生命中使用创建的实例。

所以我的建议是：随时随地使用lambda，不必担心开销。

anonymous-classjavajavalambda