Double brace initialization in Java with examples

                                           

 In this blog we cover what is double brace in java. Some of you may heard this terms first time.

What is Double Brace Intilization?

When we use initialization block for an anonymous inner class it becomes double brace initialization in java.

Double brace initialization creates an anonymous class derived from the specified class (the outer braces), and provides an initializer block within that class (the inner braces).

When we create collection we do following things.

    Declare a variable and initialize it.   

        ArrayList<String> listOfProgramming = new ArrayList<>();

    

    Insert values into collection.       

        listOfProgramming.add("Java");
        listOfProgramming.add("JavaScript");
        listOfProgramming.add("Python");

    Pass this list to method paramer.

        PrintProgrammingLanguages(listOfProgramming);

So we do above things for creating collection and add value.

But in java we can simply add values into collection using double brace intialization.

Lets see how its work.

Syntax of  double brace initialization.

    {{ }}

Lets see example of double brace intialization.

import java.util.ArrayList;

public class DoubleBraceIntilization {

    public static void main(String[] args) {

        ArrayList<String> listOfProgramming = new ArrayList<>() {{
            add("Java");
            add("JavaScript");
            add("Python");

            add("Php");

        }};
       
        System.out.println(listOfProgramming);

    }
}

Output  :-

[Java, JavaScript, Python, Php]

So in above example,

• The first brace creates a new anonymous inner class.
• The second brace creates an instance initializers like static block in Class.

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 ArrayList class, so this inner class is capable of using add() method.

And Second set of braces are nothing but instance initializers. it is like 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 we create.

Lets see another example with Map.

import java.util.HashMap;
import java.util.Set;

public class DoubleBraceIntilization {

    public static void main(String[] args) {
       
         HashMap<String,String> mapOfProgramming = new HashMap<String,String>()
             {{
                  put("1", "Java");
                  put("2", "JavaScript");
                  put("3", "Python");
                  put("4", "Php");
            }};
           
            Set<String> keySet = mapOfProgramming .keySet();
            for (String string : keySet) {
                System.out.println(string+" -> "+ mapOfProgramming .get(string));
            }
      }
}

Output :-

1 -> Java
2 -> JavaScript
3 -> Python
4 -> Php

Advantages Of Double brace intialization :-

• Code is readable.
  
• Fewer lines of code compared to the native way of creation and initialization.
• Creation initialization is done in the same expression.

Disadvantages of Double brace intialization :-

• Double brace creates extra class every time when we use.
  
• Doesn't work if the class we are trying to extend is marked final.
• Holds a hidden reference to the enclosing instance, which may cause memory leaks.

You also like :-

• Predicate in Java
• Consumer in Java
• Functional Interface in Java
• Lambda Expression in Java
• BiFunction in Java