Handling Nulls in ArrayList.addAll()

Last updated: March 7, 2025

Written by: Eugene Kovko

Reviewed by: Michal Aibin

Java List

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Try a 14-Day Free Trial of Orkes Conductor today.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.