How To Use add() and addAll() Methods for Java List

Introduction

In this article, you will learn about Java’s List methods add() and addAll().

Java List add()

This method is used to add elements to the list. There are two methods to add elements to the list.

1. add(E e): appends the element at the end of the list. Since List supports Generics, the type of elements that can be added is determined when the list is created.
2. add(int index, E element): inserts the element at the given index. The elements from the given index are shifted toward the right of the list. The method throws IndexOutOfBoundsException if the given index is out of range.

Here are some examples of List add() methods:

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.List;

public class ListAddExamples {

	public static void main(String[] args) {

		List<String> vowels = new ArrayList<>();

		vowels.add("A"); // [A]
		vowels.add("E"); // [A, E]
		vowels.add("U"); // [A, E, U]

		System.out.println(vowels); // [A, E, U]

		vowels.add(2, "I"); // [A, E, I, U]
		vowels.add(3, "O"); // [A, E, I, O, U]

		System.out.println(vowels); // [A, E, I, O, U]
	}
}

First, this code will add A, E, and U to a list and output [A, E, U].

Next, this code will add I to the index of 2 to produce [A, E, I, U]. Then, it will add O to the index of 3 to produce [A, E, I, O, U]. Finally, this list will be output to the screen.

Java List addAll()

This method is used to add the elements from a collection to the list. There are two overloaded addAll() methods.

1. addAll(Collection<? extends E> c): This method appends all the elements from the given collection to the end of the list. The order of insertion depends on the order in which the collection iterator returns them.
2. addAll(int index, Collection<? extends E> c): we can use this method to insert elements from a collection at the given index. All the elements in the list are shifted toward the right to make space for the elements from the collection.

Here are some examples of List addAll() methods:

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListAddAllExamples {

	public static void main(String[] args) {

		List<Integer> primeNumbers = new ArrayList<>();

		primeNumbers.addAll(Arrays.asList(2, 7, 11));

		System.out.println(primeNumbers); // [2, 7, 11]

		primeNumbers.addAll(1, Arrays.asList(3, 5));

		System.out.println(primeNumbers); // [2, 3, 5, 7, 11]
	}
}

First, this code creates a new list with the value of [2, 7, 11]. Then, this list is output to the screen.

Next, a second list is created with the value of [3, 5]. Then, this second list is added to the first list with addAll() with an index of 1. This results in a list of [2, 3, 5, 7, 11] that is output to the screen.

UnsupportedOperationException with List add() Methods

The List add() and addAll() method documentation states that the operation is mentioned as optional. It means that the list implementation may not support it. In this case, the list add() methods throw UnsupportedOperationException. There are two common scenarios where you will find this exception when adding elements to the list:

1. Arrays.asList(): This method returns a fixed-size list because it’s backed by the specified array. Any operation where the list size is changed throws UnsupportedOperationException.
2. Collections.unmodifiableList(List l): This method returns a unmodifiable view of the given list. So the add() operations throw UnsupportedOperationException.

Here is an example of UnsupportedOperationException with add operation on a fixed-size list:

jshell> List<Integer> ints = Arrays.asList(1,2,3);
ints ==> [1, 2, 3]

jshell> ints.add(4);
|  Exception java.lang.UnsupportedOperationException
|        at AbstractList.add (AbstractList.java:153)
|        at AbstractList.add (AbstractList.java:111)
|        at (#4:1)

First, this code creates a fixed-size list of [1, 2, 3]. Then, this code attempts to add 4 to the list. This results in throwing a UnsupportedOperationException.

Here is an example of UnsupportedOperationException with add operation on an unmodifiable view of the given list:

jshell> List<String> strs = new ArrayList<>();
strs ==> []

jshell> strs.add("A");
$6 ==> true

jshell> List<String> strs1 = Collections.unmodifiableList(strs);
strs1 ==> [A]

jshell> strs1.add("B");
|  Exception java.lang.UnsupportedOperationException
|        at Collections$UnmodifiableCollection.add (Collections.java:1058)
|        at (#8:1)

First, this code adds A to a list. Next, this code attempts to add B to an unmodifiable view of the previous list. This results in throwing a UnsupportedOperationException.

Conclusion

In this article, you learned about Java’s List methods add() and addAll().

Recommended Reading:

• Java List
• Java ArrayList

References:

• List API Docs
• StackOverflow Question