Combining Different Types of Collections in Java

1. Introduction

In this quick tutorial, we’ll explore different ways of combining collections in Java.

We’ll explore various approaches using Java and external frameworks like Guava, Apache, etc. For the introduction to Collections, have a look at this series here.

2. External Libraries to Work With Collections 

Along with native approaches, we’ll also be using external libraries. Please add the following dependencies in the pom.xml:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.5.0-M2</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-exec</artifactId>
    <version>1.3</version>
</dependency>
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

The latest versions can be found on Maven Central for Commons, Commons-exec and Guava.

3. Combining Arrays in Java

3.1. Native Java Solution

Java comes with a built-in void arraycopy() method which copies a given source array to the destination one.

We can use it in the following manner:

Object[] combined = new Object[first.length + second.length];
System.arraycopy(first, 0, combined, 0, first.length);
System.arraycopy(second, 0, combined, first.length, second.length);

In this method, along with the array objects, we also specify the position from where we need to copy, and we also pass the length parameter.

This is a native Java solution, so it doesn’t require any external libraries.

3.2. Using Java 8 Stream API

Streams offer an effective way to iterate over several different types of collections. To get started with streams, head over to the Java 8 Stream API Tutorial.

To combine arrays using a Stream, we can use this code:

Object[] combined = Stream.concat(Arrays.stream(first), Arrays.stream(second)).toArray();

Stream.concat() creates a concatenated stream in which the elements of the first stream are followed by the elements of the second stream, which is after that converted to an array using toArray() method.

The process of creating the stream is the same across different types of collections. However, we can collect it in different ways to retrieve different data structures from it.

We’ll revisit this method in sections 4.2. and 5.2. to see how we can use the same method on Lists and Sets.

3.3. Using ArrayUtils from Apache Commons

Apache commons library provides us with the addAll() method from the ArrayUtils package. We can supply destination and source array as parameters, and this method will return a combined array:

Object[] combined = ArrayUtils.addAll(first, second);

This method is also discussed in details in the Array Processing with Apache Commons Lang 3 article.

3.4. Using Guava

Guava provides us with the concat() method for the same purpose:

Object [] combined = ObjectArrays.concat(first, second, Object.class);

It can be used with different data types, and it accepts two source arrays along with the class literal to return the combined array.

4. Combining List in Java

4.1. Using Collection Native addAll() Method

The Collection interface itself provides us with the addAll() method, which adds all of the elements in the specified collection to the caller object. This is also discussed in detail in this Baeldung article:

List<Object> combined = new ArrayList<>();
combined.addAll(first);
combined.addAll(second);

Since this method is provided in the most parent interface of Collections framework, i.e., Collection interface, it can be applied across all Lists and Sets.

4.2. Using Java 8

We can use Stream and Collectors in the following way to combine Lists:

List<Object> combined = Stream.concat(first.stream(), second.stream()).collect(Collectors.toList());

This is the same as what we did in case of Arrays in section 3.2, but instead of converting it to an array, we used collectors to convert it to list. To learn about the Collectors in detail, visit Guide to Java 8’s Collectors.

We can also use flatMaps in this way:

List<Object> combined = Stream.of(first, second).flatMap(Collection::stream).collect(Collectors.toList());

First, we’re using Stream.of() which returns a sequential stream of two lists –  first and second. We’ll then pass it to flatMap which will return the contents of a mapped stream after applying the mapping function. This method also discussed in Merging Streams in Java article.

To learn more about the flatMap, head over to this Baeldung article.

4.3. Using ListUtils from Apache Commons

CollectionUtils.union does the union of two collections and returns a collection which contains all the elements:

List<Object> combined = ListUtils.union(first, second);

This method is also discussed in A Guide to Apache Commons Collections CollectionUtils. For more info, head over to section 4.9. of this article.

4.4. Using Guava

To merge a List using Guava, we’ll use Iterable which consists of the concat() method. After concatenating all the collections, we can quickly get the combined List object as shown in this example:

Iterable<Object> combinedIterables = Iterables
  .unmodifiableIterable(Iterables.concat(first, second));
List<Object> combined = Lists.newArrayList(combinedIterables);

5. Combining Set in Java

5.1. Plain Java Solution

As we had already discussed in section 4.1., Collection interface comes with a built-in addAll() method which can be used for copying Lists and Sets as well:

Set<Object> combined = new HashSet<>();
combined.addAll(first);
combined.addAll(second);

5.2. Using Java 8 Streams

The same function that we used for List objects can be applied here:

Set<Object> combined = Stream
  .concat(first.stream(), second.stream())
  .collect(Collectors.toSet());

The only notable difference here when comparing to list is that instead of using Collectors.toList(), we’re using Collectors.toSet() to accumulate all the elements from the supplied two streams into a new Set.

And similar to Lists, when using flatMaps on Sets, it would look like:

Set<Object> combined = Stream.of(first, second)
  .flatMap(Collection::stream)
  .collect(Collectors.toSet());

5.3. Using Apache Commons

Similar to the ListUtils, we can also work with the SetUtils that does a union of Set elements:

Set<Object> combined = SetUtils.union(first, second);

5.4. Using from Guava

The Guava library provides us with straightforward Sets.union() method to combine Sets in Java:

Set<Object> combined = Sets.union(first, second);

6. Combining Map in Java

6.1. Plain Java Solution

We can make use of the Map interface which itself provides us with the putAll() method which copies all of the mappings from the supplied argument of Map object to the caller Map object:

Map<Object, Object> combined = new HashMap<>();
combined.putAll(first);
combined.putAll(second);

6.2. Using Java 8

Since Java 8, the Map class consists of merge() method which accepts a key, value, and a BiFunction. We can use this with a Java 8 forEach statement to achieve merging functionality:

second.forEach((key, value) -> first.merge(key, value, String::concat));

The third parameter, i.e., remapping function is useful when the same key-value pair is present in both source maps. This function specifies what should be done with those type of values.

We can also use flatMap like this:

Map<String, String> combined = Stream.of(first, second)
  .map(Map::entrySet)
  .flatMap(Collection::stream)
  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, String::concat));

6.3. Using Apache Commons Exec

Apache Commons Exec provides us with a straightforward merge(Map<K,V> first, Map<K,V> second) method:

Map<String, String> combined = MapUtils.merge(first, second);

6.4. Using Google Guava

We can use ImmutableMap provided by Google’s Guava library. It’s putAll() method associates all of the given map’s keys and values into the built map:

Map<String, String> combined = ImmutableMap.<String, String>builder()
  .putAll(first)
  .putAll(second)
  .build();

7. Conclusion

In this article, we went through different approaches to combining different type of Collections. We merged the arrays, Lists, Sets, and Maps.