What is Double Brace initialization in Java?

Question

What is Double Brace initialization syntax ({{ ... }}) in Java?

Tacita

See #1372613 – Bruell

See also https://mcmap.net/q/46634/-efficiency-of-java-quot-double-brace-initialization-quot/45935 – Cartierbresson

Double Brace initialization is a very dangerous feature and should be used judiciously. It may break equals contract and introduce tricky memory leaks. This article describes the details. – Demoniac

The link that Andrii posted has become invalid, but I've written a blog article about it myself: Don't use the double-brace initialization trick – Streetcar

Answer 1

Double brace initialisation creates an anonymous class derived from the specified class (the outer braces), and provides an initialiser block within that class (the inner braces). e.g.

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

Note that an effect of using this double brace initialisation is that you're creating anonymous inner classes. The created class has an implicit this pointer to the surrounding outer class. Whilst not normally a problem, it can cause grief in some circumstances e.g. when serialising or garbage collecting, and it's worth being aware of this.

Intransigence

Thanks for clarifying the meaning of the inner and outer braces. I've wondered why there are suddenly two braces allowed with a special meaning, when they are in fact normal java constructs that only appear as some magical new trick. Things like that make me question Java syntax though. If you're not an expert already it can be very tricky to read and write. – Rinee

"Magic syntax" like this exists in many languages, for example almost all C-like languages support the "goes to 0" syntax of "x --> 0" in for loops which is just "x-- > 0" with weird space placement. – Unterwalden

We can just conclude that "double brace initialization" does not exist on its own, it is just a combination of creating an anonymous class and an initializer block, which, once combined, looks like a syntactical construct, but in reality, it isn't. – Harberd

Thank you! Gson returns null when we serialize something with double brace initialization because of the anonymous inner class usage. – Tollbooth

Never use this abhorrent thing. Never. – Crinkly

Answer 2

Every time someone uses double brace initialisation, a kitten gets killed.

Apart from the syntax being rather unusual and not really idiomatic (taste is debatable, of course), you are unnecessarily creating two significant problems in your application, which I've just recently blogged about in more detail here.

1. You're creating way too many anonymous classes

Each time you use double brace initialisation a new class is made. E.g. this example:

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");
        }});
    }});
}};

... will produce these classes:

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

That's quite a bit of overhead for your classloader - for nothing! Of course it won't take much initialisation time if you do it once. But if you do this 20'000 times throughout your enterprise application... all that heap memory just for a bit of "syntax sugar"?

2. You're potentially creating a memory leak!

If you take the above code and return that map from a method, callers of that method might be unsuspectingly holding on to very heavy resources that cannot be garbage collected. Consider the following example:

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;
    }
}

The returned Map will now contain a reference to the enclosing instance of ReallyHeavyObject. You probably don't want to risk that:

_{Image from http://blog.jooq.org/2014/12/08/dont-be-clever-the-double-curly-braces-anti-pattern/}

3. You can pretend that Java has map literals

To answer your actual question, people have been using this syntax to pretend that Java has something like map literals, similar to the existing array literals:

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

Some people may find this syntactically stimulating.

Eoin

"You're creating way too many anonymous classes" - looking at how (say) Scala creates anonymous classes, I'm not too sure that this is a major problem – Intransigence

Doesn't it remains a valid and nice way to declare static maps? If an HashMap is initialized with {{...}} and declared as a static field, there shouldn't be any possible memory leak, only one anonymous class and no enclosed instance references, right? – Dressage

@lorenzo-s: Yes, 2) and 3) don't apply then, only 1). Luckily, with Java 9, there's finally Map.of() for that purpose, so that'll be a better solution – Eoin

It might be worth noting that the inner maps also have references to the outer maps and hence, indirectly to ReallyHeavyObject. Also, anonymous inner classes capture all local variables used within the class body, so if you use not only constants to initialize collections or maps with this pattern, the inner class instances will capture all of them and continue to reference them even when actually removed from the collection or map. So it that case, these instances do not only need twice as necessary memory for the references, but have another memory leak in that regard. – Eley

A sane solution to the map-literals problem is ImmutableMap by Google with its fluent style builder. Unlike the double brace nonsense, it actually has the immutability semantics as would be expected of a map literal. – Softa

@JacobEckel well, we have 2021 and Java has something close enough to map literals, to stay with this answer’s example: Map source = Map.of("firstName", "John", "lastName", "Smith", "organizations", Map.of("0", Map.of("id", "1234"), "abc", Map.of("id", "5678"))) (since Java 9), which does produce an immutable map. – Eley

Why can't the garbage collector deal with it? From my perspective, there is a clear hierarchy and if there is no use for the parent anymore, start with the deepest object first, no matter if it's anonymous or not. Is it still a thing with the newer Java versions? – Uthrop

I also think it's valid for static configurations for two main reasons: 1. Map.of is just a hack and depending on how many items you pass in, each time another of() method is called with the exact number of arguments. There is a limit of 10 or so because there are 10 implementations of this method. 2. You can control the initialization of the Map / List with custom logic, while you can't with Map.of, especially if you have optional entries. I use it to generate slightly modified configurations depending on the active profile – Uthrop

The reason is to atomically construct and initialize and object in a way that's unsupported by the class's constructor. Need some references as to why creating lots of anonymous classes is bad. For example, Kotlin is growing in popularity and its functional constructs create many anonymous classes (end up creating them in bytecode). Java lambdas create anonymous classes. It's likely this is something that's been optimized away to nothing in modern VMs. It can be a memory leak, but so can lots of other things. There are a million ways to leak objects you don't know what you're doing. – Melodics

Answer 3

• The first brace creates a new Anonymous Inner Class.
• The second set of brace creates an instance initializers like static block in Class.

For example:

   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));
        }
    }
    
}

How it works

First brace creates a new Anonymous Inner Class. These inner classes are capable of accessing the behavior of their parent class. So, in our case, we are actually creating a subclass of HashSet class, so this inner class is capable of using put() method.

And Second set of braces are nothing but instance initializers. If you remember core java concepts then you can easily associate instance initializer blocks with static initializers due to similar brace like struct. Only difference is that static initializer is added with static keyword, and is run only once; no matter how many objects you create.

more

Schermerhorn

Answer 4

For a fun application of double brace initialization, see here Dwemthy’s Array in Java.

An excerpt

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;
  }}

And now, be prepared for the BattleOfGrottoOfSausageSmells and … chunky bacon!

Livy

Answer 5

I think it's important to stress that there is no such thing as "Double Brace initialization" in Java. Oracle web-site doesn't have this term. In this example there are two features used together: anonymous class and initializer block. Seems like the old initializer block has been forgotten by developers and cause some confusion in this topic. Citation from Oracle docs:

Initializer blocks for instance variables look just like static initializer blocks, but without the static keyword:

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

Vertical

Answer 6

1- There is no such thing as double braces:
I'd like to point out that there is no such thing as double brace initialization. There is only normal traditional one brace initializaition block. Second braces block has nothing to do with initialization. Answers say that those two braces initialize something, but it is not like that.

2- It's not just about anonymous classes but all classes:
Almost all answers talk that it is a thing used when creating anonymous inner classes. I think that people reading those answers will get the impression that this is only used when creating anonymous inner classes. But it is used in all classes. Reading those answers it looks like is some brand new special feature dedicated to anonymous classes and I think that is misleading.

3- The purpose is just about placing brackets after each other, not new concept:
Going further, this question talks about situation when second opening bracket is just after first opening bracket. When used in normal class usually there is some code between two braces, but it is totally the same thing. So it is a matter of placing brackets. So I think we should not say that this is some new exciting thing, because this is the thing which we all know, but just written with some code between brackets. We should not create new concept called "double brace initialization".

4- Creating nested anonymous classes has nothing to do with two braces:
I don't agree with an argument that you create too many anonymous classes. You're not creating them because an initialization block, but just because you create them. They would be created even if you did not use two braces initialization so those problems would occur even without initialization... Initialization is not the factor which creates initialized objects.

Additionally we should not talk about problem created by using this non-existent thing "double brace initialization" or even by normal one bracket initialization, because described problems exist only because of creating anonymous class so it has nothing to do with original question. But all answers with give the readers impression that it is not fault of creating anonymous classes, but this evil (non-existent) thing called "double brace initialization".

Ferguson

Answer 7

To avoid all negative effects of double brace initialization, such as:

1. Broken "equals" compatibility.
2. No checks performed, when use direct assignments.
3. Possible memory leaks.

do next things:

1. Make separate "Builder" class especially for double brace initialization.
2. Declare fields with default values.
3. Put object creation method in that class.

Example:

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 ; }
}

Usage:

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

Advantages:

1. Simply to use.
2. Do not breaks "equals" compatibility.
3. You can perform checks in creation method.
4. No memory leaks.

Disadvantages:

• None.

And, as a result, we have simplest java builder pattern ever.

See all samples at github: java-sf-builder-simple-example

Unplumbed

MyClass my = new MyClass.Builder().first(1).third("3").create(); would be at least as simple as your variant, without creating an anonymous subclass. And allow immediate validation of the values. – Eley

MyClass my = new MyClass(); my.first(1); my.third(3); I would claim that is simpler and better in every way. You don't need the bulider class simplifying the code in important ways. But then, I am certainly not a hipster. – Aegis

Answer 8

As pointed out by @Lukas Eder double braces initialization of collections must be avoided.

It creates an anonymous inner class, and since all internal classes keep a reference to the parent instance it can - and 99% likely will - prevent garbage collection if these collection objects are referenced by more objects than just the declaring one.

Java 9 has introduced convenience methods List.of, Set.of, and Map.of, which should be used instead. They're faster and more efficient than the double-brace initializer.

Perpetrate

Answer 9

It's - among other uses - a shortcut for initializing collections. Learn more ...

Offense

Well, that's one application for it, but by no means the only one. – Bruell

Answer 10

you mean something like this?

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

it's an array list initialization in creation time (hack)

Diatessaron

Answer 11

You can put some Java statements as loop to initialize collection:

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));
    }
};

But this case affect to performance, check this discussion

Dennadennard

Answer 12

The first brace creates a new Anonymous Class and the second set of brace creates an instance initializers like the static block.

Like others have pointed, it's not safe to use.

However, you can always use this alternative for initializing collections.

• Java 8

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

• Java 9

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

Shafer

Answer 13

This would appear to be the same as the with keyword so popular in flash and vbscript. It's a method of changing what this is and nothing more.

Janel

Not really. That would be like saying creating a new class is a method for changing what this is. The syntax just creates an anonymous class (so any reference to this would be referring to the object of that new anonymous class), and then uses an initializer block {...} in order to initialize the newly created instance. – Exhilarate