容易泄漏

我决定插话了。对性能的影响包括:磁盘操作+解压缩(针对jar)、类验证、烫发空间(针对Sun的Hotspot JVM)。 然而，最糟糕的是:它容易泄漏。你不能简单地回去。

Set<String> getFlavors(){
  return Collections.unmodifiableSet(flavors)
}

因此，如果集合转义到由不同的类加载器加载的任何其他部分，并且引用保留在那里，则整个类+类加载器树将被泄漏。为了避免这种情况，需要复制HashMap, new LinkedHashSet(new ArrayList(){{add("xxx);add("yyy");}})。不再那么可爱了。 我自己不使用成语，而是像new LinkedHashSet(Arrays.asList("xxx"，"YYY"));

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

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文件。

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

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

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

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

There's generally nothing particularly inefficient about it. It doesn't generally matter to the JVM that you've made a subclass and added a constructor to it-- that's a normal, everyday thing to do in an object-oriented language. I can think of quite contrived cases where you could cause an inefficiency by doing this (e.g. you have a repeatedly-called method that ends up taking a mixture of different classes because of this subclass, whereas ordinary the class passed in would be totally predictable-- in the latter case, the JIT compiler could make optimisations that are not feasible in the first). But really, I think the cases where it'll matter are very contrived.

我更倾向于从你是否想用大量的匿名类“把事情弄得乱七八糟”的角度来看待这个问题。作为一个粗略的指南，可以考虑使用这个习惯用法，就像使用匿名类作为事件处理程序一样。

在(2)中，您处于对象的构造函数内部，因此“this”指的是您正在构造的对象。这和其他构造函数没有什么不同。

As for (3), that really depends on who's maintaining your code, I guess. If you don't know this in advance, then a benchmark that I would suggest using is "do you see this in the source code to the JDK?" (in this case, I don't recall seeing many anonymous initialisers, and certainly not in cases where that's the only content of the anonymous class). In most moderately sized projects, I'd argue you're really going to need your programmers to understand the JDK source at some point or other, so any syntax or idiom used there is "fair game". Beyond that, I'd say, train people on that syntax if you have control of who's maintaining the code, else comment or avoid.

我第二Nat的答案，除了我将使用一个循环，而不是创建并立即从asList(elements)中抛出隐式列表:

static public Set<T> setOf(T ... elements) {
    Set set=new HashSet<T>(elements.size());
    for(T elm: elements) { set.add(elm); }
    return set;
    }

执行以下测试类:

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

然后反编译类文件，我看到:

public class Test {
  public void test() {
    java.util.Set flavors = new HashSet() {

      final Test this$0;

      {
        this$0 = Test.this;
        super();
        add("vanilla");
        add("strawberry");
        add("chocolate");
        add("butter pecan");
      }
    };
  }
}

在我看来，这并不是非常低效。如果我担心这样的东西的性能，我会分析它。上面的代码回答了你的问题#2:你在内部类的隐式构造函数(和实例初始化式)中，所以“this”指的是这个内部类。

是的，这个语法是模糊的，但是注释可以阐明模糊的语法用法。为了澄清语法，大多数人都熟悉静态初始化块(JLS 8.7 static Initializers):

public class Sample1 {
    private static final String someVar;
    static {
        String temp = null;
        ..... // block of code setting temp
        someVar = temp;
    }
}

您还可以使用类似的语法(没有“static”这个词)来使用构造函数(JLS 8.6实例初始化器)，尽管我从未在生产代码中看到过这种用法。这一点很少为人所知。

public class Sample2 {
    private final String someVar;

    // This is an instance initializer
    {
        String temp = null;
        ..... // block of code setting temp
        someVar = temp;
    }
}

如果没有默认构造函数，则编译器将{和}之间的代码块转换为构造函数。考虑到这一点，解开双括号代码:

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

最里面的大括号之间的代码块被编译器转换为构造函数。最外面的花括号分隔了匿名内部类。这是使一切都非匿名的最后一步:

public void test() {
  Set<String> flavors = new MyHashSet();
}

class MyHashSet extends HashSet<String>() {
    public MyHashSet() {
        add("vanilla");
        add("strawberry");
        add("chocolate");
        add("butter pecan");
    }
}

对于初始化的目的，我认为没有任何开销(或者小到可以忽略不计)。但是，每次使用flavor都不会违背HashSet，而是违背MyHashSet。这可能有一个很小的开销(很可能可以忽略不计)。但是，在我担心之前，我会先分析一下。

同样，对于您的问题#2，上面的代码在逻辑上和显式地等价于双大括号初始化，并且它使“this”指的地方很明显:指向扩展HashSet的内部类。

如果您对实例初始化器的详细信息有疑问，请查看JLS文档中的详细信息。