How do you create a stream from a collection in Java?

Table of Contents

• Introduction
• Methods to Create a Stream from a Collection
  • 1. Using the stream() Method
    • Example: Creating a Stream from a List
    • Output:
  • 2. Using the parallelStream() Method
    • Example: Creating a Parallel Stream from a List
    • Output (order may vary due to parallel processing):
  • 3. Using Stream.of() to Create a Stream
    • Example: Creating a Stream from Multiple Values
    • Output:
  • 4. Using Arrays.stream() to Create a Stream from an Array
    • Example: Creating a Stream from an Array
    • Output:
  • 5. Using Stream.concat() to Combine Multiple Streams
    • Example: Concatenating Two Streams
    • Output:
• Practical Example: Filtering and Mapping a Stream from a Collection
  • • Example: Filtering and Mapping a List of Numbers
    • Output:
• Conclusion

Introduction

In Java, the Stream API, introduced in Java 8, allows you to process collections of data in a functional style. A Stream is a sequence of elements that can be processed in parallel or sequentially. Creating a stream from a collection is an essential step to leverage stream operations like filtering, mapping, and reducing data. This guide explains how to create a stream from various types of collections and how to work with them.

Methods to Create a Stream from a Collection

1. Using the stream() Method

The most common and straightforward way to create a stream is by calling the **stream()** method on a collection. This method creates a sequential stream from any **Collection** (such as List, Set, or Queue).

Example: Creating a Stream from a List

Output:

In this example, **fruits.stream()** creates a stream from the list fruits, and the **forEach()** operation is used to print each element of the stream.

2. Using the parallelStream() Method

If you need to process large collections more efficiently, you can create a parallel stream using the **parallelStream()** method. This method enables parallel processing, which can improve performance on multi-core processors.

Example: Creating a Parallel Stream from a List

Output (order may vary due to parallel processing):

In this example, **parallelStream()** creates a parallel stream, which processes the elements in parallel across multiple threads.

3. Using Stream.of() to Create a Stream

The **Stream.of()** method is useful when you want to create a stream from a predefined set of elements, rather than from a collection like a list or set.

Example: Creating a Stream from Multiple Values

Output:

This example creates a stream directly from a sequence of values, without needing to wrap them in a collection.

4. Using Arrays.stream() to Create a Stream from an Array

If you have an array and want to create a stream, you can use **Arrays.stream()**. This method converts an array into a stream, allowing you to perform stream operations on its elements.

Example: Creating a Stream from an Array

Output:

Here, **Arrays.stream(fruits)** creates a stream from the fruits array, allowing you to use stream operations.

5. Using Stream.concat() to Combine Multiple Streams

You can combine multiple streams into a single stream using **Stream.concat()**. This method is useful when you need to merge two or more streams into one before processing them.

Example: Concatenating Two Streams

Output:

In this example, **Stream.concat()** combines two streams into one before processing them with **forEach()**.

Practical Example: Filtering and Mapping a Stream from a Collection

Let’s put some of the stream operations together to demonstrate how you can process a collection using filtering and mapping.

Example: Filtering and Mapping a List of Numbers

Output:

In this example, **filter()** removes odd numbers, and **map()** doubles each remaining number, all done within the stream.

Conclusion

In Java, creating a stream from a collection or an array is simple and highly useful when processing data. The **stream()** method allows you to create a sequential stream from any **Collection**, while **parallelStream()** enables parallel processing for better performance. The **Stream.of()** method lets you create a stream from a set of values, and **Arrays.stream()** works for arrays. Additionally, you can combine multiple streams using **Stream.concat()**.

Streams in Java allow you to process data in a functional and concise manner, making it easier to perform transformations, filters, and reductions on your data collections.