Java“双大括号初始化”的效率?

在Java的隐藏特性中，最上面的答案提到了双大括号初始化，语法非常诱人:

Set<String> flavors = new HashSet<String>() {{
    add("vanilla");
    add("strawberry");
    add("chocolate");
    add("butter pecan");
}};

这个习惯用法创建了一个匿名的内部类，其中只有一个实例初始化式，它“可以使用任何[…]]方法”。

主要问题:这真的像听起来那么低效吗?它的使用应该仅限于一次性的初始化吗?(当然还有炫耀!)

第二个问题:新的HashSet必须是实例初始化器中使用的“this”…有人能解释一下原理吗?

第三个问题:在产品代码中使用这个习语是否过于晦涩?

非常非常好的回答，谢谢大家。关于问题(3)，人们认为语法应该清楚(尽管我建议偶尔注释一下，特别是如果您的代码将传递给可能不熟悉它的开发人员)。

对于问题(1)，生成的代码应该快速运行。额外的.class文件确实会导致jar文件混乱，并略微减慢程序启动速度(感谢@coobird测量)。@Thilo指出，垃圾收集可能会受到影响，在某些情况下，额外加载类的内存成本可能是一个因素。

问题(2)对我来说是最有趣的。如果我理解了答案，DBI中发生的事情是匿名内部类扩展了new操作符所构造的对象的类，因此有一个“this”值引用正在构造的实例。非常整洁。

Overall, DBI strikes me as something of an intellectual curiousity. Coobird and others point out you can achieve the same effect with Arrays.asList, varargs methods, Google Collections, and the proposed Java 7 Collection literals. Newer JVM languages like Scala, JRuby, and Groovy also offer concise notations for list construction, and interoperate well with Java. Given that DBI clutters up the classpath, slows down class loading a bit, and makes the code a tad more obscure, I'd probably shy away from it. However, I plan to spring this on a friend who's just gotten his SCJP and loves good natured jousts about Java semantics! ;-) Thanks everyone!

7/2017: Baeldung很好地总结了双大括号初始化，并认为这是一种反模式。

2017年12月12日:@Basil Bourque指出，在新的Java 9中，你可以说:

Set<String> flavors = Set.of("vanilla", "strawberry", "chocolate", "butter pecan");

这肯定是正确的选择。如果你还在使用以前的版本，可以看看谷歌Collections的ImmutableSet。

当前回答

当我过于沉迷于匿名内部类时，有一个问题:

2009/05/27  16:35             1,602 DemoApp2$1.class
2009/05/27  16:35             1,976 DemoApp2$10.class
2009/05/27  16:35             1,919 DemoApp2$11.class
2009/05/27  16:35             2,404 DemoApp2$12.class
2009/05/27  16:35             1,197 DemoApp2$13.class

/* snip */

2009/05/27  16:35             1,953 DemoApp2$30.class
2009/05/27  16:35             1,910 DemoApp2$31.class
2009/05/27  16:35             2,007 DemoApp2$32.class
2009/05/27  16:35               926 DemoApp2$33$1$1.class
2009/05/27  16:35             4,104 DemoApp2$33$1.class
2009/05/27  16:35             2,849 DemoApp2$33.class
2009/05/27  16:35               926 DemoApp2$34$1$1.class
2009/05/27  16:35             4,234 DemoApp2$34$1.class
2009/05/27  16:35             2,849 DemoApp2$34.class

/* snip */

2009/05/27  16:35               614 DemoApp2$40.class
2009/05/27  16:35             2,344 DemoApp2$5.class
2009/05/27  16:35             1,551 DemoApp2$6.class
2009/05/27  16:35             1,604 DemoApp2$7.class
2009/05/27  16:35             1,809 DemoApp2$8.class
2009/05/27  16:35             2,022 DemoApp2$9.class

这些都是我在制作一个简单应用程序时生成的类，并使用了大量的匿名内部类——每个类将被编译成一个单独的类文件。

如前所述，“双大括号初始化”是一个带有实例初始化块的匿名内部类，这意味着每次“初始化”都会创建一个新类，所有这些通常都是为了创建单个对象。

考虑到Java虚拟机在使用这些类时需要读取所有这些类，这可能会导致字节码验证过程等花费一些时间。更不用说存储所有这些类文件所需的磁盘空间的增加了。

在使用双大括号初始化时，似乎会有一些开销，所以太过分可能不是一个好主意。但正如艾迪在评论中指出的那样，不可能完全确定其影响。

仅供参考，双大括号初始化如下:

List<String> list = new ArrayList<String>() {{
    add("Hello");
    add("World!");
}};

它看起来像Java的一个“隐藏”特性，但它只是一个重写:

List<String> list = new ArrayList<String>() {

    // Instance initialization block
    {
        add("Hello");
        add("World!");
    }
};

它基本上是一个实例初始化块，是匿名内部类的一部分。

Joshua Bloch为Project Coin设计的Collection Literals方案是这样的:

List<Integer> intList = [1, 2, 3, 4];

Set<String> strSet = {"Apple", "Banana", "Cactus"};

Map<String, Integer> truthMap = { "answer" : 42 };

遗憾的是，它既没有出现在Java 7中，也没有出现在Java 8中，而是被无限期地搁置了。

实验

下面是我测试过的一个简单的实验——通过add方法将“Hello”和“World!”元素添加到1000个数组列表中，使用以下两种方法:

方法1:双大括号初始化

List<String> l = new ArrayList<String>() {{
  add("Hello");
  add("World!");
}};

方法2:实例化一个数组列表并添加

List<String> l = new ArrayList<String>();
l.add("Hello");
l.add("World!");

我创建了一个简单的程序，写出一个Java源文件，使用以下两种方法执行1000个初始化:

测试1:

class Test1 {
  public static void main(String[] s) {
    long st = System.currentTimeMillis();

    List<String> l0 = new ArrayList<String>() {{
      add("Hello");
      add("World!");
    }};

    List<String> l1 = new ArrayList<String>() {{
      add("Hello");
      add("World!");
    }};

    /* snip */

    List<String> l999 = new ArrayList<String>() {{
      add("Hello");
      add("World!");
    }};

    System.out.println(System.currentTimeMillis() - st);
  }
}

测试2:

class Test2 {
  public static void main(String[] s) {
    long st = System.currentTimeMillis();

    List<String> l0 = new ArrayList<String>();
    l0.add("Hello");
    l0.add("World!");

    List<String> l1 = new ArrayList<String>();
    l1.add("Hello");
    l1.add("World!");

    /* snip */

    List<String> l999 = new ArrayList<String>();
    l999.add("Hello");
    l999.add("World!");

    System.out.println(System.currentTimeMillis() - st);
  }
}

请注意，初始化1000个ArrayList和扩展ArrayList的1000个匿名内部类所消耗的时间是使用System检查的。currentTimeMillis，所以定时器的分辨率不是很高。在我的Windows系统上，分辨率大约是15-16毫秒。

这两项试验进行了10次，结果如下:

Test1 Times (ms)           Test2 Times (ms)
----------------           ----------------
           187                          0
           203                          0
           203                          0
           188                          0
           188                          0
           187                          0
           203                          0
           188                          0
           188                          0
           203                          0

可以看到，双大括号初始化的执行时间大约为190毫秒。

同时，ArrayList初始化执行时间为0毫秒。当然，应该考虑定时器分辨率，但它很可能低于15毫秒。

因此，这两个方法的执行时间似乎有明显的差异。这两个初始化方法似乎确实有一些开销。

是的，通过编译Test1双大括号初始化测试程序生成了1000个.class文件。

2009-05-29 03:59:26

其他回答

我正在研究这个问题，并决定做一个比有效答案提供的更深入的测试。

代码如下:https://gist.github.com/4368924

这就是我的结论

I was surprised to find that in most of the run tests the internal initiation was actually faster (almost double in some cases). When working with large numbers the benefit seems to fade away. Interestingly, the case that creates 3 objects on the loop loses it's benefit rans out sooner than on the other cases. I am not sure why this is happening and more testing should be done to reach any conclusions. Creating concrete implementations may help to avoid the class definition to be reloaded (if that's what's happening) However, it is clear that not much overhead it observed in most cases for the single item building, even with large numbers. One set back would be the fact that each of the double brace initiations creates a new class file that adds a whole disk block to the size of our application (or about 1k when compressed). A small footprint, but if it's used in many places it could potentially have an impact. Use this 1000 times and you are potentially adding a whole MiB to you applicaiton, which may be concerning on an embedded environment. My conclusion? It can be ok to use as long as it is not abused.

让我知道你的想法:)

2012-12-24 12:17:41

Mario Gleichman描述了如何使用Java 1.5泛型函数来模拟Scala List字面量，但遗憾的是，最终得到的是不可变列表。

他定义了这个类:

package literal;

public class collection {
    public static <T> List<T> List(T...elems){
        return Arrays.asList( elems );
    }
}

并这样使用它:

import static literal.collection.List;
import static system.io.*;

public class CollectionDemo {
    public void demoList(){
        List<String> slist = List( "a", "b", "c" );
        List<Integer> iList = List( 1, 2, 3 );
        for( String elem : List( "a", "java", "list" ) )
            System.out.println( elem );
    }
}

谷歌Collections现在是Guava的一部分，它支持类似的列表构造思想。在这次采访中，贾里德·列维说:

[…在我编写的几乎每个Java类中，使用最多的特性是减少Java代码中重复击键次数的静态方法。输入如下命令非常方便: Map<OneClassWithALongName, AnotherClassWithALongName> = Maps.newHashMap(); List<String> animals =列表。immutableList(“猫”，“狗”，“马”);

7/10/2014:如果它能像Python一样简单就好了:

动物=['猫'，'狗'，'马']

2/21/2020:在Java 11中，你现在可以说:

animals =列表。(猫，狗，马)

2009-10-22 06:06:37

这将为每个成员调用add()。如果你能找到一种更有效的方法将项放入散列集中，那么就使用它。注意，内部类可能会生成垃圾，如果您对此很敏感的话。在我看来，上下文似乎是new返回的对象，也就是HashSet。如果你需要问…更有可能的是:在你之后的人会知道这一点吗?它容易理解和解释吗?如果两个问题你都能回答“是”，那就随便用吧。

2009-05-29 03:56:09

要创建集合，你可以使用varargs工厂方法来代替双大括号初始化:

public static Set<T> setOf(T ... elements) {
    return new HashSet<T>(Arrays.asList(elements));
}

谷歌Collections库有很多这样的方便方法，以及大量其他有用的功能。

至于这个习语的晦涩性，我一直在产品代码中遇到并使用它。我更关心的是那些被允许编写产品代码的习惯用法所迷惑的程序员。

2009-05-29 04:20:21