The ArrayList class in Java is a commonly used data structure. One of its methods, addAll(), allows us to add all elements from a specified collection to the list. However, this method does not handle null values well. If we pass a null reference to addAll(), it will throw a NullPointerException. This can be a common source of errors in Java programs. In this article, we will explore the problem with addAll() and discuss various strategies to handle null references.

1. Problem Statement

The addAll() method is defined as follows:

public boolean addAll(Collection<? extends E> c)

When you pass a null collection to this method, it throws a NullPointerException. Here’s a simple example to demonstrate this problem:

AddAllWithNulls.java

public class AddAllWithNulls {

 public static void main(String[] args) {
 List<String> myList = new ArrayList<>();
 myList.add("Apple");

 List<String> elementsToAdd1 = null; // This collection is null

 List<String> elementsToAdd2 = new ArrayList<>(); // Empty collection
 elementsToAdd2.add("Banana");
 elementsToAdd2.add("Guava");

 // This line throws NullPointerException
 myList.addAll(elementsToAdd1);
 myList.addAll(elementsToAdd2);
 System.out.println(myList);

 }
}

In this example, elementsToAdd is declared but not initialized, resulting in a null reference. When we call myList.addAll(elementsToAdd1), the null reference is passed as the argument, causing the NullPointerException. This exception occurs because the addAll() method attempts to access methods or properties of the null collection, which is not allowed.

Output

Exception in thread "main" java.lang.NullPointerException
	at java.base/java.util.ArrayList.addAll(ArrayList.java:702)
	at com.jcg.addallwithnulls.AddAllWithNulls.main(AddAllWithNulls.java:26)

To prevent a NullPointerException when using addAll(), below are several strategies we can employ.

2. Null Check Before Calling addAll()

The simplest way is to perform a null check before calling addAll():

FilterNullsBeforeAdd.java

public class FilterNullsBeforeAdd {

 public static void addToMyList(List<String> myList, List<String> elementsToAdd) {
 if (elementsToAdd != null) {
 myList.addAll(elementsToAdd);
 } else {
 // Handle the null case (e.g., throw exception, log warning)
 }
 }

 public static void main(String[] args) {

 List<String> myList = new ArrayList<>();
 myList.add("Apple");

 List<String> elementsToAdd1 = null; // This collection is null

 List<String> elementsToAdd2 = new ArrayList<>(); // Empty collection
 elementsToAdd2.add("Banana");
 elementsToAdd2.add("Guava");

 addToMyList(myList, elementsToAdd1); // Would throw NullPointerException without the check
 addToMyList(myList, elementsToAdd2);
 System.out.println(myList);

 }
}

Output is:

[Apple, Banana, Guava]

3. Using Optional

We can use java.util.Optional to make the code more expressive and handle null values in a more functional way:

HandleNullsWithOptional.java

public class HandleNullsWithOptional {

 public static void addToMyList(List<String> myList, List<String> elementsToAdd) {
 Optional.ofNullable(elementsToAdd).ifPresent(myList::addAll);
 }

 public static void main(String[] args) {
 List<String> myList = new ArrayList<>();
 myList.add("Apple");

 List<String> elementsToAdd1 = null; // This collection is null

 List<String> elementsToAdd2 = new ArrayList<>(); // Empty collection
 elementsToAdd2.add("Banana");
 elementsToAdd2.add("Guava");

 addToMyList(myList, elementsToAdd1); // Would throw NullPointerException without the check
 addToMyList(myList, elementsToAdd2);
 System.out.println(myList);

 }
}

This approach uses the Optional class to handle the null check in a more concise and readable way.

4. Providing a Default Empty List

Another approach is to provide a default empty list when the input is null.

 public static void addToMyList(List<String> myList, List<String> elementsToAdd) {
 myList.addAll(Optional.ofNullable(elementsToAdd).orElse(Collections.emptyList()));
 }

This way, if elementsToAdd is null, an empty list is passed to addAll().

5. Using Streams

We can use Java Streams to handle null elements in a collection more elegantly:

FilterNullWithStreams.java

public class FilterNullWithStreams {

 public static void addToMyListStream(List<String> myList, List<String> elementsToAdd) {

 // Using Streams to handle null check and add elements
 myList.addAll(
 Stream.ofNullable(elementsToAdd)
 .flatMap(Collection::stream)
 .collect(Collectors.toList())
 );

 }

 public static void main(String[] args) {
 List<String> myList = new ArrayList<>();
 myList.add("Apple");

 List<String> elementsToAdd1 = null; // This collection is null

 List<String> elementsToAdd2 = new ArrayList<>(); // Empty collection
 elementsToAdd2.add("Banana");
 elementsToAdd2.add("Guava");

 addToMyListStream(myList, elementsToAdd1); // Would throw NullPointerException without the check
 addToMyListStream(myList, elementsToAdd2);

 System.out.println(myList);
 }
}

Output is:

6. Conclusion

In this article, we explored the issue of NullPointerException when using the ArrayList.addAll() method with null collections. We demonstrated the problem with a simple example and discussed various strategies for handling null references. These strategies include performing a null check before calling addAll(), using Optional to handle null values, providing a default empty list, and utilizing Java Streams to filter and add non-null elements.

7. Download the Source Code

This was an article on how to handle null values in an ArrayList in Java.