Initialize an ArrayList with Zeroes or Null in Java

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.