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

当我对匿名的内部类过于着迷时，这就是问题所在：

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

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

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

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

使用双括号初始化时似乎有一点开销，因此过于过分可能不是一个好主意。但正如Eddie在评论中指出的那样，不可能绝对确定其影响。

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

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，而是被无限期地搁置了。

实验

这是我测试过的简单实验 - 用元素制作1000个，然后通过方法添加，使用两种方法：ArrayList"Hello""World!"add

方法 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 秒和 1000 个匿名内部类扩展所花费的时间是使用 检查的，因此计时器没有很高的分辨率。在我的Windows系统上，分辨率约为15-16毫秒。ArrayListArrayListSystem.currentTimeMillis

两个测试的 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 毫秒。

同时，初始化执行时间为0 ms。当然，应该考虑计时器分辨率，但很可能在15 ms以下。ArrayList

因此，这两种方法的执行时间似乎存在明显差异。看起来这两种初始化方法确实存在一些开销。

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

到目前为止尚未指出此方法的一个属性是，由于创建了内部类，因此将在其范围内捕获整个包含类。这意味着，只要您的 Set 处于活动状态，它就会保留一个指向包含实例 （） 的指针，并防止该实例被垃圾回收，这可能是一个问题。this$0

这一点，以及即使常规的HashSet可以正常工作（甚至更好）也首先创建新类的事实使我不想使用这种构造（即使我非常渴望语法糖）。

第二个问题：新的 HashSet 必须是实例初始值设定项中使用的“this”...任何人都可以阐明该机制吗？我天真地以为“this”指的是初始化“flavors”的对象。

这就是内部类的工作方式。它们有自己的 ，但它们也有指向父实例的指针，以便您也可以在包含对象上调用方法。在命名冲突的情况下，内部类（在你的例子中是HashSet）优先，但你可以用类名前缀“this”来获取外部方法。this

public class Test {

    public void add(Object o) {
    }

    public Set<String> makeSet() {
        return new HashSet<String>() {
            {
              add("hello"); // HashSet
              Test.this.add("hello"); // outer instance 
            }
        };
    }
}

为了明确要创建的匿名子类，您也可以在其中定义方法。例如覆盖HashSet.add()

    public Set<String> makeSet() {
        return new HashSet<String>() {
            {
              add("hello"); // not HashSet anymore ...
            }

            @Override
            boolean add(String s){

            }

        };
    }