当我过于沉迷于匿名内部类时，有一个问题:
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文件。
