Add elements of a Stream into an existing List in Java
This post will discuss how to add elements of a stream to an existing list in Java.
1. Using Collectors.toCollection() method
We can use a Collector to add elements to an existing list, as shown below:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; class Main { // Generic method to add elements of a stream to an existing list public static<T> void addToList(List<T> target, Stream<T> source) { source.collect(Collectors.toCollection(() -> target)); } public static void main(String[] args) { List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3)); addToList(list, Stream.of(4, 5)); System.out.println(list); } } |
Output:
[1, 2, 3, 4, 5]
The above program violates the requirement of a supplier, as the supplier returns an existing list each time it is called, instead of a new, empty list.
If a supplier that returns the same list is passed to Collectors#toCollection(), each thread of parallel stream doesn’t get its own list for intermediate accumulation and appends its results to the specified list instead. So above code will fail if the stream is run in parallel.
One workaround is to call the sequential() on the stream before accumulating:
|
1 2 3 4 5 6 |
// Generic method to add elements of a stream to an existing list public static<T> void addToList(List<T> target, Stream<T> source) { source.sequential() .collect(Collectors.toCollection(() -> target)); } |
2. Using Stream.forEachOrdered() with List.add() method
We can add elements of a stream to an existing collection by using forEachOrdered() along with a method reference to List#add().
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Stream; class Main { // Generic method to add elements of a stream to an existing list public static<T> void addToList(List<T> target, Stream<T> source) { source.forEachOrdered(target::add); } public static void main(String[] args) { List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3)); addToList(list, Stream.of(4, 5)); System.out.println(list); } } |
Output:
[1, 2, 3, 4, 5]
This approach works for sequential and parallel streams, but it does not benefit from concurrency as the method reference passed to forEachOrdered() will always be executed sequentially.
3. Using List.addAll() method + Collectors
We have seen that we can fill a list by repeatedly calling the add() method on every element of the stream. But instead of calling add() every time, a better approach is to replace it with a single call the addAll() method, as shown below. This approach, however, creates an intermediate list.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; class Main { // Generic method to add elements of a stream to an existing list public static<T> void addToList(List<T> target, Stream<T> source) { target.addAll(source.collect(Collectors.toList())); } public static void main(String[] args) { List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3)); addToList(list, Stream.of(4, 5)); System.out.println(list); } } |
Output:
[1, 2, 3, 4, 5]
4. Using Stream.concat() method + Collectors
This approach doesn’t mutate the original list but creates a new list containing elements from the specified stream and original list.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; class Main { // Generic method to add elements of a stream to an existing list public static<T> List<T> addToList(List<T> target, Stream<T> source) { return Stream.concat(target.stream(), source) .collect(Collectors.toList()); } public static void main(String[] args) { List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3)); list = addToList(list, Stream.of(4, 5)); System.out.println(list); } } |
Output:
[1, 2, 3, 4, 5]
That’s all about adding elements of a Stream into an existing List in Java.
Thanks for reading.
To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.
Like us? Refer us to your friends and support our growth. Happy coding :)