Double brace initialization refers to the syntax in Java where an extra set of braces are used when initializing arrays, collections, or other objects. For example:
...
List<String> names = new ArrayList<String>() {{
add("John");
add("Sarah");
add("Mike");
}};This syntax leverages an anonymous inner class to initialize the list inline while still creating the ArrayList instance.
At first glance, the syntax can seem confusing compared to typical initialization approaches. Here is a comparison of some of the pros and cons:
| Advantages | Disadvantages |
|---|---|
| Concise single line initialization | Performance overhead from extra class creation |
| Self-contained initialization logic | Lack of reuse for the initialization code |
| More readable in some cases | Can confuse developers unfamiliar with the syntax |
Concise One-Liner Initialization
Without double brace initialization, you would need separate statements:
...
List<String> names = new ArrayList<>();
names.add("John");
names.add("Sarah");
names.add("Mike");The double brace approach consolidates this into a single concise line.
Readable Self-Contained Initialization Logic
Keeping the initialization right where the variable is declared can improve readability, containing all logic for that specific initialization in one spot.
However, there are some downsides to consider:
Performance Overhead
Behind the scenes, an extra anonymous class is generated:
...
List<String> names = new ArrayList<String>() {
{ // init block
add("John");
add("Sarah");
add("Mike");
}
};The class creation increases memory usage and impacts performance.
Lack of Reuse
The initialization logic inside the braces is not reusable. To extract, you would need to place it into a separate method.
Confusion Factor
Some Java developers find this syntax confusing at first glance since it diverges from typical object creation patterns.
Overall, double brace initialization trades off performance and reuse for brevity. The conciseness benefit may justify usage for small cases, but for code where efficiency or reuse matters, it is usually better avoided.
Frequently Asked Questions
When would you use double brace initialization in Java?
For small cases where concise one-liner initialization is valuable, like initializing a small fixed-size list or map inline.
When should you avoid double brace initialization?
For initialization logic that needs high performance or will be reused. Also avoid if the developer audience is unfamiliar with the syntax.
What is the alternative if I want to avoid double brace init?
The standard object creation pattern in multiple statements. Or factor out reusable initialization logic into a separate factory method.
Does double brace syntax only work on collections?
No, it can initialize arrays and other objects as well, though collections are the most common use case.
Is there a performance gain sometimes?
No, due to the extra class allocation the performance is always worse. The only gain is in code conciseness.
