What Is Double Couplet Initialization Inwards Java? Anti Designing Example

Double duet initialization is a Java idiom to initialize a Collection similar a list, laid as well as map at the fourth dimension of declaration. At times, you lot take a listing of fixed elements e.g. supported products, supported currencies or to a greater extent than or less other config, as well as on the location initialization reduces draw of code as well as improves readability. Double duet initialization idiom becomes pop because in that location is no touchstone way to do as well as initialize Collection at the same fourth dimension inwards Java. Unfortunately, dissimilar to a greater extent than or less other language, Java doesn't back upwardly collection literals yet. Due to this limitation, creating an unmodifiable List amongst small-scale numbers of elements requires many lines of code involving creating list, repeatedly calling add() method to add together those elements as well as and then travel wrapping it into unmodifiable listing every bit shown below :

List<Integer> listing = new ArrayList<>(); list.add(2); list.add(3); list.add(5); list.add(7);         List<Integer> unmodifiableList = Collections.unmodifiableList(list);

This is quite verbose, as well as because it cannot live expressed inwards a unmarried expression, static lists must live populated inwards static initializer blocks rather than via a to a greater extent than convenient plain initializer.

Double duet initialization idiom tin do this inwards simply i draw every bit shown below:

List<Integer> listing = Collections.unmodifiableList(new ArrayList<Integer>() {{         add(2);         add(3);         add(5); }});

You tin besides initialize HashMap amongst values using double duet initialization every bit following:

Map<Integer, String> intToString = new HashMap<Integer, String>(){{          put(1, "one");          put(2, "two");          put(3, "three");           }};

This looks pretty, but it has its ain laid of disadvantages, which made it an anti-pattern, we'll encounter them inwards side yesteryear side section.

Pros as well as Cons of Double Brace Initialization inwards Java

Double duet Initialization idiom internally it uses the instance initializer build inwards an anonymous inner class. Which way it quite obscure, as well as it costs an extra bird every fourth dimension you lot purpose it. It besides holds a hidden reference to the enclosing instance, which may drive retentivity leaks. You cannot purpose diamond operator in that location every bit good because it's non allowed to infer types inwards the anonymous class.

Pros:
1) Less draw of code
2) Creation as well as Initialization inwards the same expression

Cons:
2) Obscure, internally uses the instance initializer build of the anonymous class.
2) It toll an extra bird every fourth dimension you lot purpose it
3) It holds a hidden reference to the enclosing instance, which may drive memory leaks.

Due to its disadvantage as well as improve option double duet initialization is immediately considered every bit an anti-pattern inwards Java world.

Alternatives of Double Brace Initialization Idiom inwards Java

The Good affair is that you lot convey improve alternatives to grade the same consequence inwards Java e.g. you lot tin do as well as initialize an ArrayList amongst values inwards i draw yesteryear using Copy constructor from Collection class, every bit shown below :

List<Integer> listing = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(2, 3, 5)));

Arrays.asList() returns a fixed length list, which is passed to ArrayList re-create constructor. Remember, in that location is departure betwixt fixed length listing returned from Arrays.asList() as well as the i returned from Collections.unmodifiableList(). You cannot add or take elements from the ArayList, but you lot tin modify the value at whatever index using set() inwards the instance of onetime but non amongst the listing returned yesteryear Collections.unmodifiableList() method.

This is the best method if you lot desire a small-scale list, but it becomes obscure as well as less obvious if you lot take Set or other Collection, since i has to do a List earlier creating the Set, but it's all the same improve than double duet initialization because it doesn't do anonymous inner classes every fourth dimension you lot purpose it. See Core Java for Impatient for to a greater extent than details.

There is i to a greater extent than option of double duet initialization available, solely if you lot are running inwards Java 8. The JDK 8 Stream API tin live used to build small-scale collections, yesteryear combining current mill methods as well as collectors, every bit shown below:

List<String> listing = Collections.unmodifiableList(Stream.of("abc", "bcd", "cde").collect(toList()));

If you lot desire  a Set, you lot tin purpose Collectors.toSet() method instead of Collectors.toList(), every bit seen inwards next instance :

Set<String> laid = Collections.unmodifiableSet(Stream.of("abc", "bcd", "cde").collect(toSet()));

By the way, The streams collectors brand no guarantees almost the mutability of collections they return. In Java 8, the returned collections are ordinary, mutable collections such every bit ArrayList, HashSet, as well as HashMap, but this mightiness modify inwards time to come JDK releases.


That's all almost Double duet initialization idiom inwards Java. It's ok for i of the uses, generally for testing as well as demo, but it's non skillful plenty to live used inwards production code. Due to its cons, Double duet initialization has expire an antipattern nowadays, particularly amongst to a greater extent than suitable alternatives available. I all the same purpose double duet initialization for initializing static maps, but that's it. For List as well as Set, I prefer the combination of Arrays.asList() as well as re-create constructor of Collection class. If I am running Java 8 as well as then I purpose Stream API as well as Collectors to do the job.

Further Learning
article)

Why is static code analysis of import for Java application? (article)

10 Best Practices to follow piece naming variables, bird as well as methods inwards Java? (article)

Must know multi-threading as well as concurrency best practices for Java Programmers (article)

Why you lot should non telephone squall upwardly System.exit() on Java Web Application? (answer)

Why purpose SLF4j over Log4j for logging inwards Java? (answer)

10 Articles Every Programmer must Read. (list)

Why should you lot favor Composition over Inheritance inwards Java? (answer)

Some Practical tips to avoid NullPointerException inwards Java? (answer)

Why getter as well as setter are improve than populace fields inwards Java? (answer)

Why use @Override notation inwards Java? (tip)

How to write thread-safe code inwards Java? (tip)

10 best practices to follow piece commenting code (article)