java - Lambda表达式和等效的匿名类

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

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，不必担心开销。

关于java - Lambda表达式和等效的匿名类，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/64123700/