One not very well-known feature in Java is the use of the “double brace initialization” technique. This technique allows for the creation of anonymous inner classes to initialize a collection, such as a List or Set, in a more concise and readable way.
For example, instead of using a traditional for loop to add elements to a List, you can use double brace initialization to create and initialize the List in a single line of code:
List<String> list = new ArrayList<String>() {{
add("item1");
add("item2");
add("item3");
}};However, this technique should be used with caution, as it can lead to memory leaks if not used properly.
The reason that double brace initialization can lead to memory leaks is that it creates an anonymous inner class, which has an implicit reference to the enclosing class (i.e. the class in which the inner class is defined).
This reference will be kept alive as long as the inner class is alive, which means that it will prevent the enclosing class from being garbage collected.
If the inner class is used to initialize a static field, or if it’s a member of a singleton, then the reference to the enclosing class will be kept alive for the lifetime of the application, causing a memory leak.
To avoid memory leaks, it’s recommended to use the double brace initialization technique only for local variables, and make sure that the inner class doesn’t hold references to the enclosing class, or any other objects that can’t be garbage collected.
Alternatively, instead of using double brace initialization, you can use the Collections.addAll() method to add multiple items to a collection in a more efficient and less error-prone way.