1. Overview
In this quick tutorial, we’ll investigate how to initialize a List using one-liners.
2. Create From an Array
We can create a List from an array. And thanks to array literals, we can initialize them in one line:
List<String> list = Arrays.asList(new String[]{"foo", "bar"});
We can trust the varargs mechanism to handle the array creation. With that, we can write more concise and readable code:
@Test
public void givenArraysAsList_thenInitialiseList() {
List<String> list = Arrays.asList("foo", "bar");
assertTrue(list.contains("foo"));
}
The result instance of this code implements the List interface, but it isn’t a java.util.ArrayList or a LinkedList. Instead, it’s a List backed by the original array, which has two implications that we’ll look at in the rest of this section.
Although the class’s name happens to be ArrayList, it’s in the java.util.Arrays package.
2.1. Fixed Size
The result instance from Arrays.asList() has a fixed size. It’s not convenient if we want to add/remove elements to/from the list:
@Test(expected = UnsupportedOperationException.class)
public void givenArraysAsList_whenAdd_thenUnsupportedException() {
List<String> list = Arrays.asList("foo", "bar");
list.add("baz");
}
To solve this, we can pass the Arrays.asList() result to a List class’s constructor. Then, we can add/remove elements to/from the newly constructed list:
List<String> list = new ArrayList<>(Arrays.asList("foo", "bar"));
list.add("baz");
assertEquals(List.of("foo", "bar", "baz"), list);
list.remove("baz");
assertEquals(List.of("foo", "bar"), list);
2.2. Shared Reference
The original array and the list share the same references to the objects:
@Test
public void givenArraysAsList_whenCreated_thenShareReference(){
String[] array = {"foo", "bar"};
List<String> list = Arrays.asList(array);
array[0] = "baz";
assertEquals("baz", list.get(0));
}
2.3. Common Pitfall of Initializing a List
In Java, auto-casting (implicit casting) occurs when a data type with a smaller range is assigned to a data type with a larger range. For example, when we assign an int to a long, Java automatically performs the cast because long can accommodate larger values than int. Here’s a simple example:
int intNum = 42;
long longNum = intNum;
assertEquals(42L, longNum);
So, we may want to initialize a List
List<Long> listOfLong = new ArrayList<Long>(Arrays.asList(1, 2, 3));
In the example, 1, 2, 3 are int values. Arrays.asList(1, 2, 3) creates a List in the type of List
However, this line of code doesn’t compile:
java: no suitable constructor found for ArrayList(java.util.List<java.lang.Integer>)
This is because auto-casting can occur between primitive data types, but it doesn’t directly apply to their corresponding wrapper classes like Integer and Long. Further, Java doesn’t automatically cast a List
We can fix the problem by using long literal representation (a number with the ‘L‘ or ‘l‘ suffix):
List<Long> listOfLongFixedSize = Arrays.asList(1L, 2L, 3L);
List<Long> listOfLong = new ArrayList<>(Arrays.asList(1L, 2L, 3L));
List<Long> expected = List.of(1L, 2L, 3L);
assertEquals(expected, listOfLongFixedSize);
assertEquals(expected, listOfLong);
3. Create From a Stream (Java 8)
We can easily convert a Stream into any kind of Collection.
Therefore, with the factory methods for Streams, we can create and initialize lists in one line:
@Test
public void givenStream_thenInitializeList(){
List<String> list = Stream.of("foo", "bar")
.collect(Collectors.toList());
assertTrue(list.contains("foo"));
}
We should note here that Collectors.toList() doesn’t guarantee the exact implementation of the returned List.
There’s no general contract about the mutability, serializability or thread safety of the returned instance. So, our code shouldn’t rely on any of these properties.
Some sources highlight that Stream.of(…).collect(…) may have a larger memory and performance footprint than Arrays.asList(). But in almost all cases, it’s such a micro-optimization that there is little difference.
4. Factory Methods (Java 9)
JDK 9 introduces several convenient factory methods for collections:
List<String> list = List.of("foo", "bar", "baz");
Set<String> set = Set.of("foo", "bar", "baz");
One important detail is that the returned instances are immutable. Beyond that, the factory methods have several advantages in space efficiency and thread safety.
This topic is explored more in this article.
5. Double-Brace Initialization
In several places, we can find a method called double-brace initialization, which looks like this:
@Test
public void givenAnonymousInnerClass_thenInitialiseList() {
List<String> cities = new ArrayList() {{
add("New York");
add("Rio");
add("Tokyo");
}};
assertTrue(cities.contains("New York"));
}
The name “double-brace initialization” is quite misleading. While the syntax may look compact and elegant, it dangerously hides what is going on under the hood.
There isn’t actually a double-brace syntax element in Java; those are two blocks formatted intentionally this way.
With the outer braces, we declare an anonymous inner class that will be a subclass of the ArrayList. We can declare the details of our subclass inside these braces.
As usual, we can use instance initializer blocks, and that is where the inner pair of braces comes from.
The brevity of this syntax is tempting. However, it’s considered an anti-pattern.
To read more about double-brace initialization, have a look at our article here.
6. Conclusion
Modern Java offers several options to create a Collection in one line. The method we choose is almost entirely down to personal preference rather than technical reasoning.
An important takeaway is that, although it looks graceful, the anti-pattern of anonymous inner class initialization (aka double brace) has many negative side effects.
As always, the code is available over on GitHub.