Java 8 – Convert Stream to List

Introduction

In Java 8, the Stream API revolutionized how we process collections of data. Streams allow you to perform complex operations like filtering, mapping, and reducing in a functional and declarative manner.

However, after processing data in a stream, you often need to convert the stream back into a list. This is especially useful when you want to further manipulate or return the processed data in a collection format. Fortunately, Java 8 provides straightforward methods to convert streams to lists efficiently.

In this guide, we’ll explore how to convert a stream to a list using various methods. We will also look at scenarios where this conversion is particularly useful.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Basic Conversion from Stream to List
  • Converting a Stream with Filtered Elements
  • Converting a Stream of Custom Objects
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Accepts a stream of elements.
• Converts the stream into a list after performing some operations.
• Outputs the resulting list.

Example 1:

• Input: Stream of integers [1, 2, 3, 4, 5]
• Output: List of integers [1, 2, 3, 4, 5]

Example 2:

• Input: Stream of strings ["apple", "banana", "cherry"], after filtering strings with length greater than 5.
• Output: List of filtered strings ["banana", "cherry"]

Solution Steps

1. Create a Stream: Start with a stream of elements that you want to convert to a list.
2. Convert the Stream to a List: Use the collect() method with Collectors.toList() to perform the conversion.
3. Display the Result: Print the resulting list.

Java Program

Basic Conversion from Stream to List

The most straightforward way to convert a stream to a list is by using the collect() method with Collectors.toList().

import java.util.List;
import java.util.stream.Stream;
import java.util.stream.Collectors;

/**
 * Java 8 - Basic Conversion from Stream to List
 * Author: https://www.rameshfadatare.com/
 */
public class StreamToListBasic {

    public static void main(String[] args) {
        // Step 1: Create a stream of integers
        Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

        // Step 2: Convert the stream to a list
        List<Integer> numberList = numberStream.collect(Collectors.toList());

        // Step 3: Display the result
        System.out.println("List: " + numberList);
    }
}

Output

List: [1, 2, 3, 4, 5]

Explanation

• The Stream.of(1, 2, 3, 4, 5) method creates a stream of integers.
• The collect(Collectors.toList()) method collects the elements of the stream into a list.

Converting a Stream with Filtered Elements

You can also filter elements from a stream before converting it to a list. This is useful when you need to create a list that only contains elements matching certain criteria.

import java.util.List;
import java.util.stream.Stream;
import java.util.stream.Collectors;

/**
 * Java 8 - Convert a Stream with Filtered Elements to List
 * Author: https://www.rameshfadatare.com/
 */
public class StreamToListWithFilter {

    public static void main(String[] args) {
        // Step 1: Create a stream of strings
        Stream<String> fruitStream = Stream.of("apple", "banana", "cherry", "date");

        // Step 2: Filter the stream to include only strings with length greater than 5
        List<String> filteredList = fruitStream
            .filter(fruit -> fruit.length() > 5)
            .collect(Collectors.toList());

        // Step 3: Display the result
        System.out.println("Filtered List: " + filteredList);
    }
}

Output

Filtered List: [banana, cherry]

Explanation

• The filter(fruit -> fruit.length() > 5) method filters the stream to include only elements with a length greater than 5.
• The filtered elements are then collected into a list using collect(Collectors.toList()).

Converting a Stream of Custom Objects

When working with custom objects, you can easily convert a stream of these objects into a list. This is particularly useful when you need to manipulate or return a collection of objects after stream processing.

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Java 8 - Convert a Stream of Custom Objects to List
 * Author: https://www.rameshfadatare.com/
 */
public class StreamToListCustomObjects {

    public static void main(String[] args) {
        // Step 1: Create a stream of students
        Stream<Student> studentStream = Stream.of(
            new Student("Raj", 25),
            new Student("Anita", 30),
            new Student("Vikram", 22)
        );

        // Step 2: Convert the stream to a list
        List<Student> studentList = studentStream.collect(Collectors.toList());

        // Step 3: Display the result
        studentList.forEach(student -> 
            System.out.println(student.getName() + ": " + student.getAge())
        );
    }
}

// Custom class Student
class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Output

Raj: 25
Anita: 30
Vikram: 22

Explanation

• The Stream.of(...) method creates a stream of Student objects.
• The collect(Collectors.toList()) method collects the Student objects into a list.
• The resulting list is then printed.

Advanced Considerations

• Immutable Lists: If you need the resulting list to be immutable, consider using Collectors.toUnmodifiableList() in Java 10 or later.

• Parallel Streams: If you are working with large datasets, consider using parallel streams (parallelStream()) to improve performance during processing.

• Error Handling: Ensure proper error handling when processing streams, especially when working with complex operations or external data sources.

Conclusion

This guide provides methods for converting a stream to a list in Java 8, covering basic conversions, filtering, and working with custom objects. The Stream API, combined with Collectors, offers a powerful and flexible way to collect and manage data after processing. By converting a stream to a list, you can easily manipulate or return processed data in a collection format.