# Java 8 Convert a Stream to List Example

**Date:** 2018-01-09

Converting Java Streams to Lists: A Comprehensive Guide

Working with streams in Java 8 and later versions often necessitates converting a stream of data into a more readily usable collection, such as a List.  While the Stream API doesn't directly offer a `toList()` method, several effective strategies allow for this conversion. This article explores five common approaches, comparing their advantages and disadvantages to help developers choose the best method for their needs.  The core challenge stems from the fact that streams are designed for declarative, functional-style processing, aiming for efficiency and potentially parallel execution, whereas Lists are mutable, ordered collections.  Bridging this gap requires careful consideration.

The Standard Approach: Using Collectors.toList()

The most recommended and widely accepted method leverages the `collect()` method inherent to the Stream class, paired with the `Collectors.toList()` utility.  This approach elegantly combines the functional aspect of stream processing with the need for a concrete List object.  The `collect()` method takes a `Collector` as an argument, and `Collectors.toList()` provides a pre-built collector specifically designed to gather stream elements into a new List. This is generally the preferred method due to its clarity, efficiency, and wide acceptance within the Java community.  It directly reflects the intended purpose and maintains code readability.  The process is straightforward: the stream is processed, and the `collect()` operation gathers the results into a freshly created List, ready for further manipulation or use.

Using toCollection() for Custom Collections

Beyond the basic `toList()` method, Java offers flexibility through the `toCollection()` method.  This enables creation of Lists using specific implementations, like `ArrayList` or `LinkedList`, rather than the default List type created by `toList()`.  This approach involves providing a supplier—a function that generates a new, empty collection instance—allowing customization of the underlying List structure.  Using a method reference, such as `ArrayList::new`, provides a concise and readable way to specify the collection type.  The `toCollection()` method's power comes from adapting to various collection needs, especially when specific characteristics of `ArrayList` (fast random access) or `LinkedList` (efficient insertions and deletions) are required. However, for simple List conversions, `Collectors.toList()` remains simpler and often sufficient.

Iterative Approach: forEach() and forEachOrdered()

For simpler scenarios or educational purposes, the `forEach()` method provides a direct, imperative way to populate a List. This involves iterating through the stream's elements individually and adding them to a pre-initialized List. While functional, this approach sacrifices some of the elegance and potential performance optimizations inherent to the collector-based methods.  The `forEach()` method, however, doesn't guarantee order preservation, especially in parallel streams.  For scenarios where element order is paramount, the `forEachOrdered()` method provides a solution.  This guarantees that elements are added to the List in the same order as they appear in the stream, although this comes at the potential cost of parallel processing efficiency. The iterative method, while intuitive, is less efficient and less preferred than the collector-based alternatives for most practical situations.

Converting to an Array and then to a List

The Stream API provides a `toArray()` method for direct conversion to an array.  This isn't a direct List conversion but offers an alternative route.  After converting to an array, a List can be subsequently created from the array elements.  This multi-step approach is generally less efficient than direct List creation with collectors and lacks the conciseness and readability of the preferred methods.  The initial conversion to an array might introduce unnecessary overhead, especially if the final goal is a List.  The subsequent creation of the List from the array further adds to the complexity and reduces performance compared to methods directly generating a List.  This method should be considered only if array manipulation is an integral part of the broader process.

Project Setup and Practical Implementation

Illustrative examples would typically include creating a Maven-based Java project in an IDE like Eclipse.  This involves defining project dependencies to incorporate Java 8 features or later versions (ensuring support for the Stream API).  The process would entail creating a Java class to contain the code and the inclusion of relevant import statements for stream processing classes, notably `java.util.stream.Collectors` and `java.util.ArrayList`, or other List implementations as desired.  Running the code then involves launching the Java application within the IDE, and checking the output for the correctly converted List.  The code itself would instantiate a stream (for example, from a collection), apply transformations (like `map` or `filter` if needed), and finally convert the resulting stream into a List using any of the aforementioned methods. Error handling would typically include appropriate checks to prevent issues such as null streams or unexpected data types.  Detailed logging would be useful for observing the intermediate steps of the stream processing and the final result.

Conclusion

While there are multiple approaches to converting Java Streams to Lists, the use of `Stream.collect(Collectors.toList())` emerges as the most efficient, readable, and recommended method.  It aligns perfectly with the functional paradigm of streams and provides a direct and clean solution. Other approaches, such as `toCollection()` and the iterative methods using `forEach()` and `forEachOrdered()`, serve specific needs or educational purposes but should be chosen judiciously, weighing the trade-offs against the benefits of the standard method.  The direct conversion to an array followed by List creation should generally be avoided unless there are other compelling reasons related to array-specific operations.  Choosing the right method for your specific use case is key to ensuring efficient and maintainable code.


**[Read more](https://examples.javacodegeeks.com/core-java/java-8-convert-stream-list-example/)**