1. Overview
In this tutorial, we’ll explore different ways to initialize a Java ArrayList with all values null or zero. We can also play with the initializations as we like and initialize the lists with different numerical values or objects.
2. Using for Loop
When thinking about the problem of initializing the ArrayList with a desired value or object, the first solution that comes to our mind is using a simple for loop. And rightfully so, this is a straightforward and viable solution:
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 0; i< 10; i++) {
arrayList.add(null);
// arrayList.add(0);
}
We declare an empty ArrayList and use the add() method for a loop.
3. Using the ArrayList Constructor Method
Another method, maybe not so well-known, would be to use one of the constructors of the ArrayList class. This takes as an argument a collection and constructs a new ArrayList containing the elements of the specified list in the order the collection’s iterator returns them. To provide the desired list to our constructor, we’ll use the nCopies() function of the Collections class. This function takes as arguments the item and the number of copies needed. We can also write a unit test to check that our constructor works appropriately:
@Test
public void whenInitializingListWithNCopies_thenListIsCorrectlyPopulated() {
// when
ArrayList<Integer> list = new ArrayList<>(Collections.nCopies(10, 0));
// then
Assertions.assertEquals(10, list.size());
Assertions.assertTrue(list.stream().allMatch(elem -> elem == 0));
}
We’ll check if the list has the desired number of elements and if all are equal to our demanded value. There are multiple ways to check if the elements of a list are all the same. For our example, we use the allMatch() function of the Java Stream API.
4. Using Java Stream API
In the previous example, we used the Java Stream API to determine if we initialized the list correctly. But, the Java Stream is capable of much more. We can use the static function generate() to produce an infinite amount of elements based on a supplier:
@Test
public void whenInitializingListWithStream_thenListIsCorrectlyPopulated() {
// when
ArrayList<Integer> listWithZeros = Stream.generate(() -> 0)
.limit(10).collect(Collectors.toCollection(ArrayList::new));
ArrayList<Object> listWithNulls = Stream.generate(() -> null)
.limit(10).collect(Collectors.toCollection(ArrayList::new));
// then
Assertions.assertEquals(10, listWithZeros.size());
Assertions.assertTrue(listWithZeros.stream().allMatch(elem -> elem == 0));
Assertions.assertEquals(10, listWithNulls.size());
Assertions.assertTrue(listWithNulls.stream().allMatch(Objects::isNull));
}
The limit() function takes as an argument a number. This represents the number of elements the stream should be limited to, and the method returns a new Stream consisting of objects picked from the original stream.
5. Using IntStream
We can initialize the list with a desired numeric value using the IntStream class. This is a class derived from the BaseStream, like the Stream interface. This implies that this class is capable of most things that the Stream class is capable of. This class let us create a stream of primitive numbers. Then we use the boxed() function to wrap the primitives to objects. After that, we can easily collect all the numbers generated:
@Test
public void whenInitializingListWithIntStream_thenListIsCorrectlyPopulated() {
// when
ArrayList<Integer> list = IntStream.of(new int[10])
.boxed()
.collect(Collectors.toCollection(ArrayList::new));
// then
Assertions.assertEquals(10, list.size());
Assertions.assertTrue(list.stream().allMatch(elem -> elem == 0));
}
We should also consider that this method works only to insert primitive numbers. So, we can’t use this method to initialize the list with null values.
6. Using Arrays.asList
The asList() is a method of java.util.Arrays class. Using this method, we can convert an array to a collection. So, for this method, we should initialize an array. Because our array contains only null values at the initialization, we use the method fill() to populate it with our desired value, 0, in our case. This method works like nCopies(), populating our array with the value given as a parameter. After filling the array with zeros, we can finally convert it to a list using the toList() function:
@Test
public void whenInitializingListWithAsList_thenListIsCorrectlyPopulated() {
// when
Integer[] integers = new Integer[10];
Arrays.fill(integers, 0);
List<Integer> integerList = Arrays.asList(integers);
// then
Assertions.assertEquals(10, integerList.size());
Assertions.assertTrue(integerList.stream().allMatch(elem -> elem == 0));
}
In this example, we should consider that we got a List as a result and not an ArrayList. And if we try to add a new element to the list, we’ll get an UnsupportedOperationException. This problem can be solved easily using the method presented in the previous section. We need to convert the List into an ArrayList. And we can do this by changing the integerList declaration into:
List<Integer> integerList = new ArrayList<>(Arrays.asList(integers));
Also, we can make this method add null values to our list just by removing the fill() method call. As said before, arrays are initialized with null values by default.
7. Using Vector Class
Like the ArrayList class, the Java Vector class represents a growable array of objects. In addition, Vector is a Java legacy class that implements the List interface. So we can easily cast it to a list. However, despite all the similarities between the two entities, they’re different and have different use cases. A rather significant difference is that the Vector class has all methods synchronized.
The advantage of the Vector in our problem is that it can be initialized with any number of elements. Besides this, all its elements will be null by default:
@Test
public void whenInitializingListWithVector_thenListIsCorrectlyPopulated() {
// when
List<Integer> integerList = new Vector<>() {{setSize(10);}};
// then
Assertions.assertEquals(10, integerList.size());
Assertions.assertTrue(integerList.stream().allMatch(elem -> elem == null));
}
We use the function setSize() to initialize the Vector with the desired number of elements. After that, the Vector will fill itself with null values. We must consider that this method only helps us if we want to insert null values in our list.
We can also transform the list to an ArrayList by using the constructor of the ArrayList class like in the previous examples or by using the method addAll() to add all elements in our newly initialized empty ArrayList.
8. Conclusion
In this quick tutorial, we’ve explored all the alternatives when we need to initialize an ArrayList with null or 0 values. In particular, we went through examples using streams, arrays, vectors, or sample loops.
As usual, you can find all the code samples over on GitHub.