Efficient Ways to Concatenate Lists in Java

Introduction

In Java, combining multiple lists into a single list is a common task. This can be achieved through several methods, each with its own set of advantages and trade-offs. In this tutorial, we will explore different techniques for joining two or more lists without modifying the original lists. We’ll cover solutions from basic approaches to advanced ones using Java 8 features.

Basic Approach

The most straightforward way to concatenate two lists in Java is by creating a new list and adding all elements from the source lists into it:

List<String> newList = new ArrayList<>(listOne);
newList.addAll(listTwo);

Explanation

• new ArrayList<>(): Initializes an empty ArrayList that will hold the combined elements.
• addAll(): Adds all elements of listTwo to newList, preserving order.

This approach is simple and works well for small lists but involves creating a new list object, which may have performance implications for very large datasets.

Java 8 Enhancements

Java 8 introduced streams and functional programming capabilities that provide more concise ways to concatenate lists.

Using Stream.concat()

List<String> newList = Stream.concat(listOne.stream(), listTwo.stream())
                             .collect(Collectors.toList());

Explanation

• Stream.concat(): Combines two or more streams into a single stream.
• .stream(): Converts the lists to streams, enabling functional operations.
• .collect(Collectors.toList()): Collects elements of the concatenated stream back into a new list.

This method is clean and leverages Java 8’s powerful stream API for seamless concatenation.

Stream.of() with flatMap()

List<String> newList = Stream.of(listOne, listTwo)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

Explanation

• Stream.of(): Creates a stream from multiple collections.
• .flatMap(Collection::stream): Flattens the collection of streams into a single stream containing all elements.
• .collect(Collectors.toList()): Collects these elements into a new list.

This approach is flexible as it allows concatenating more than two lists easily, making it versatile for varying scenarios.

Advanced Solution: CompositeUnmodifiableList

For cases where preserving original references and preventing memory bloat is crucial, implementing a custom composite list can be beneficial:

public class CompositeUnmodifiableList<E> extends AbstractList<E> {

    private final List<? extends E> list1;
    private final List<? extends E> list2;

    public CompositeUnmodifiableList(List<? extends E> list1, List<? extends E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }
    
    @Override
    public E get(int index) {
        if (index < list1.size()) {
            return list1.get(index);
        }
        return list2.get(index - list1.size());
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }
}

Usage

List<String> newList = new CompositeUnmodifiableList<>(listOne, listTwo);

Explanation

• CompositeUnmodifiableList: A custom list implementation that combines two lists without duplicating references.
• .get(int index): Retrieves elements by delegating to the appropriate underlying list based on index.
• .size(): Returns the combined size of both lists.

This method is efficient in terms of memory usage and works well when you do not need a standalone concatenated list but rather an iterable view over multiple collections.

Conclusion

Joining lists in Java can be accomplished through various methods, each with its own strengths. Whether using basic operations, leveraging Java 8 streams for cleaner code, or employing advanced techniques like composite lists for memory efficiency, the choice depends on your specific requirements and constraints. Understanding these options allows you to select the most appropriate method for your use case.