Handling Nulls in ArrayList.addAll()

1. Overview

Working comfortably with Collection API is one of the most crucial skills of a Java developer. In this tutorial, we’ll concentrate on the ArrayList and its addAll() method.

While addAll() is the most convenient way to add a sequence of elements to a target ArrayList, it doesn’t work well with nulls.

2. null and addAll()

As was stated previously, the addAll() method doesn’t work well with null. It would throw the NullPointerException if we pass a null reference:

@ParameterizedTest
@NullSource
void givenNull_whenAddAll_thenAddThrowsNPE(List<String> list) {
    ArrayList<String> strings = new ArrayList<>();
    assertThatExceptionOfType(NullPointerException.class)
      .isThrownBy(() -> strings.addAll(list));
}

While it’s good that this exception is explicit, it’s not very good that we may learn about the issue only at runtime.

3. Simple Check

The most basic way we can ensure that we don’t pass null to the addAll() method is to have a simple if statement with a check:

@ParameterizedTest
@NullSource
void givenNull_whenAddAllWithCheck_thenNoNPE(List<String> list) {
    ArrayList<String> strings = new ArrayList<>();
    assertThatNoException().isThrownBy( () -> {
        if (list != null) {
            strings.addAll(list);
        }
    });
}

This is a perfectly valid way to handle this situation. However, it might be seen as too verbose and imperative. Let’s try to make this code more straightforward.

4. Custom Check Method

Let’s take the previous solution and refactor it a bit. All we need to do is to extract the null check logic to a separate method:

private static void addIfNonNull(List<String> list, ArrayList<String> strings) {
    if (list != null) {
        strings.addAll(list);
    }
}

The client code would look a bit better as we moved the implementation away:

@ParameterizedTest
@NullSource
void givenNull_whenAddAllWithExternalizedCheck_thenNoNPE(List<String> list) {
    ArrayList<String> strings = new ArrayList<>();
    assertThatNoException().isThrownBy( () -> {
        addIfNonNull(list, strings);
    });
}

However, in this case, we’re passing the list to a method and mutating it inside. This is the tradeoff in this case: the code is more readable, but it’s unclear how we mutate the List.

5. Empty by Default

Another approach is to transparently convert null to an empty List. We’ll be using CollectionUtils from the Apache Commons library. However, as the logic is trivial, we can implement it ourselves as well:

@ParameterizedTest
@NullSource
void givenNull_whenAddAllWithCollectionCheck_thenNoNPE(List<String> list) {
    ArrayList<String> strings = new ArrayList<>();
    assertThatNoException().isThrownBy( () -> {
        strings.addAll(CollectionUtils.emptyIfNull(list));
    });
}

This might be a better approach, especially if we use this list elsewhere. At the same time, the best way to use this conversion is to apply it as early as possible, preventing passing nulls throughout our application. For example, nullable types in Kotlin aim to solve this issue.

6. Optional

While Kotlin has nullable types, Java approaches this issue using Optional. This is just a wrapper class that notifies users that the object might not be present. However, it contains a nice API to work with nullable values:

@ParameterizedTest
@NullSource
void givenNull_whenAddAllWithOptional_thenNoNPE(List<String> list) {
    ArrayList<String> strings = new ArrayList<>();
    assertThatNoException().isThrownBy( () -> {
        Optional.ofNullable(list).ifPresent(strings::addAll);
    });
}

This is a simple solution to implement null checks. It doesn’t require any third-party libraries, and the logic is easy to read and reason about.

7. Streams

If we’re working with a collection of nullable Lists, we can use the filter() method to ignore nulls:

@ParameterizedTest
@MethodSource("listProvider")
void givenCollectionOfNullableLists_whenFilter_thenNoNPE(List<List<String>> listOfLists) {
    ArrayList<String> strings = new ArrayList<>();
    assertThatNoException().isThrownBy(() -> {
        listOfLists.stream().filter(Objects::nonNull).forEach(strings::addAll);
    });
}

The API is similar to the one that was used by Optional and is relatively easy to understand.

8. Conclusion

Tracking null values in an application might be challenging. However, it’s crucial to account for cases where we can get a NullPointerException to ensure the application’s robustness.

We can use various techniques to address these issues, from simple if statements and Optionals to third-party API solutions. However, we should remember to account for them as early as possible. The best way to do so is not to allow null values in the first place.

As always, all the code from this tutorial is available over on GitHub.