Java 中的双大括号初始化是什么？

Question

Java 中的双大括号初始化语法 ( {{... }} ) 是什么？

Answer 1

双花括号初始化创建一个从指定类（外花括号）派生的匿名类，并在该类（内花括号）中提供一个初始化块。 例如

new ArrayList<Integer>() {{
   add(1);
   add(2);
}};

请注意，使用此双括号初始化的效果是您正在创建匿名内部类。 创建的类具有指向周围外部类的隐式this指针。 虽然通常不是问题，但在某些情况下（例如在序列化或垃圾收集时）可能会导致悲伤，并且值得注意这一点。

Answer 2

每次有人使用双括号初始化时，都会有一只小猫被杀死。

除了语法相当不寻常且不是真正惯用的（当然，品味是有争议的）之外，您在应用程序中不必要地创建了两个重大问题， 我最近刚刚在博客中更详细地讨论了这些问题。

1. 你创建了太多匿名类

每次使用双括号初始化时，都会创建一个新类。 例如这个例子：

Map source = new HashMap(){{
    put("firstName", "John");
    put("lastName", "Smith");
    put("organizations", new HashMap(){{
        put("0", new HashMap(){{
            put("id", "1234");
        }});
        put("abc", new HashMap(){{
            put("id", "5678");
        }});
    }});
}};

...将产生这些类：

Test$1$1$1.class
Test$1$1$2.class
Test$1$1.class
Test$1.class
Test.class

这对您的类加载器来说是相当多的开销 - 一无所获！ 当然，如果你做一次，它不会花费太多初始化时间。 但是，如果您在整个企业应用程序中执行此操作 20'000 次...所有堆内存只是为了一点“语法糖”？

2. 您可能会造成内存泄漏！

如果您采用上述代码并从方法返回该映射，则该方法的调用者可能会毫无戒心地占用无法被垃圾收集的非常重的资源。 考虑以下示例：

public class ReallyHeavyObject {

    // Just to illustrate...
    private int[] tonsOfValues;
    private Resource[] tonsOfResources;

    // This method almost does nothing
    public Map quickHarmlessMethod() {
        Map source = new HashMap(){{
            put("firstName", "John");
            put("lastName", "Smith");
            put("organizations", new HashMap(){{
                put("0", new HashMap(){{
                    put("id", "1234");
                }});
                put("abc", new HashMap(){{
                    put("id", "5678");
                }});
            }});
        }};

        return source;
    }
}

返回的Map现在将包含对封闭的ReallyHeavyObject实例的ReallyHeavyObject 。 您可能不想冒险：

_{图片来自http://blog.jooq.org/2014/12/08/dont-be-clever-the-double-curly-braces-anti-pattern/}

3. 你可以假装 Java 有地图文字

为了回答您的实际问题，人们一直在使用这种语法来假装 Java 具有类似于地图文字的东西，类似于现有的数组文字：

String[] array = { "John", "Doe" };
Map map = new HashMap() {{ put("John", "Doe"); }};

有些人可能会发现这在句法上很刺激。

Answer 3

• 第一个大括号创建一个新的匿名内部类。
• 第二组大括号创建了一个实例初始化器，如类中的静态块。

例如：

   public class TestHashMap {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<String,String>(){
        {
            put("1", "ONE");
        }{
            put("2", "TWO");
        }{
            put("3", "THREE");
        }
        };
        Set<String> keySet = map.keySet();
        for (String string : keySet) {
            System.out.println(string+" ->"+map.get(string));
        }
    }
    
}

这个怎么运作

第一个大括号创建一个新的匿名内部类。 这些内部类能够访问其父类的行为。 所以，在我们的例子中，我们实际上是在创建 HashSet 类的子类，所以这个内部类能够使用 put() 方法。

第二组大括号只不过是实例初始值设定项。 如果您还记得核心 Java 概念，那么您可以轻松地将实例初始化块与静态初始化块相关联，因为类似于结构的大括号。 唯一不同的是静态初始化器添加了static关键字，并且只运行一次； 无论您创建了多少对象。

更多的

Answer 4

有关双括号初始化的有趣应用，请参阅此处的 Java 中的 Dwemthy 数组。

摘录

private static class IndustrialRaverMonkey
  extends Creature.Base {{
    life = 46;
    strength = 35;
    charisma = 91;
    weapon = 2;
  }}

private static class DwarvenAngel
  extends Creature.Base {{
    life = 540;
    strength = 6;
    charisma = 144;
    weapon = 50;
  }}

现在，准备好BattleOfGrottoOfSausageSmells和……厚实的培根！

Answer 5

我认为强调Java 中没有“双括号初始化”这样的东西很重要。 Oracle 网站没有这个术语。 在这个例子中，有两个特性一起使用：匿名类和初始化块。 似乎旧的初始化程序块已被开发人员遗忘，并在此主题中引起了一些混乱。 来自Oracle 文档的引用：

实例变量的初始化块看起来就像静态初始化块，但没有 static 关键字：

{
    // whatever code is needed for initialization goes here
}

Answer 6

1- 没有双大括号这样的东西：
我想指出，没有双括号初始化这样的东西。 只有普通的传统大括号初始化块。 第二个大括号块与初始化无关。 答案说这两个大括号初始化了一些东西，但事实并非如此。

2- 这不仅仅是关于匿名类，而是所有类：
几乎所有的答案都说它是创建匿名内部类时使用的东西。 我认为阅读这些答案的人会觉得这仅在创建匿名内部类时使用。 但它用于所有类。 阅读这些答案，它看起来像是一些专用于匿名课程的全新特殊功能，我认为这是一种误导。

3- 目的只是将括号放在一起，而不是新概念：
更进一步，这个问题讨论了第二个左括号紧接在第一个左括号之后的情况。 在普通类中使用时，通常在两个大括号之间有一些代码，但它是完全一样的。 所以这是一个放置括号的问题。 所以我认为我们不应该说这是一些令人兴奋的新事物，因为这是我们都知道的事物，只是在括号之间写了一些代码。 我们不应该创建称为“双括号初始化”的新概念。

4- 创建嵌套匿名类与两个大括号无关：
我不同意您创建太多匿名类的论点。 您不是因为初始化块而创建它们，而是因为您创建了它们。 即使您没有使用两个大括号初始化，它们也会被创建，因此即使没有初始化也会发生这些问题......初始化不是创建初始化对象的因素。

另外我们不应该谈论使用这种不存在的东西“双括号初始化”甚至是普通的单括号初始化所产生的问题，因为所描述的问题只是因为创建匿名类而存在，所以它与原始问题无关。 但是所有的答案都给读者的印象是，创建匿名类不是错，而是这种称为“双括号初始化”的邪恶（不存在）东西。

Answer 7

为了避免双括号初始化的所有负面影响，例如：

1. 破坏“等于”兼容性。
2. 使用直接赋值时不执行检查。
3. 可能的内存泄漏。

做接下来的事情：

1. 制作单独的“Builder”类，特别是用于双括号初始化。
2. 使用默认值声明字段。
3. 将对象创建方法放在该类中。

例子：

public class MyClass {
    public static class Builder {
        public int    first  = -1        ;
        public double second = Double.NaN;
        public String third  = null      ;

        public MyClass create() {
            return new MyClass(first, second, third);
        }
    }

    protected final int    first ;
    protected final double second;
    protected final String third ;

    protected MyClass(
        int    first ,
        double second,
        String third
    ) {
        this.first = first ;
        this.second= second;
        this.third = third ;
    }

    public int    first () { return first ; }
    public double second() { return second; }
    public String third () { return third ; }
}

用法：

MyClass my = new MyClass.Builder(){{ first = 1; third = "3"; }}.create();

好处：

1. 简单地使用。
2. 不要破坏“等于”兼容性。
3. 您可以在创建方法中执行检查。
4. 没有内存泄漏。

缺点：

• 没有任何。

因此，我们有最简单的 Java 构建器模式。

查看 github 上的所有示例：java-sf-builder-simple-example

Answer 8

正如@Lukas Eder 所指出的，必须避免集合的双括号初始化。

它创建一个匿名内部类，并且由于所有内部类都保留对父实例的引用，因此如果这些集合对象被更多对象而不是声明对象引用，则它可以 - 并且 99% 可能会 - 防止垃圾收集。

Java 9 引入了便利方法List.of 、 Set.of和Map.of ，应该改用它们。 它们比双括号初始化器更快、更有效。

Answer 9

它是 - 除其他用途外 - 初始化集合的快捷方式。 了解更多 ...

Answer 10

您可以将一些 Java 语句作为循环来初始化集合：

List<Character> characters = new ArrayList<Character>() {
    {
        for (char c = 'A'; c <= 'E'; c++) add(c);
    }
};

---

Random rnd = new Random();

List<Integer> integers = new ArrayList<Integer>() {
    {
         while (size() < 10) add(rnd.nextInt(1_000_000));
    }
};

但是这种情况会影响性能，请查看此讨论

Answer 11

你的意思是这样的？

List<String> blah = new ArrayList<String>(){{add("asdfa");add("bbb");}};

这是创建时的数组列表初始化（hack）

Answer 12

第一个大括号创建一个新的匿名类，第二个大括号创建一个实例初始化器，如静态块。

就像其他人指出的那样，使用它是不安全的。

但是，您始终可以使用此替代方法来初始化集合。

• 爪哇 8

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

• 爪哇 9

List<String> list = List.of("A", "B", "C");

Answer 13

这似乎与在 flash 和 vbscript 中如此流行的 with 关键字相同。 这是一种改变现状的方法，仅this而已。