Java 8 introduced a revolutionary new feature called Streams, which revolutionized the way Java developers process data collections. With Streams, Java developers can perform complex operations on collections using a concise and efficient syntax.

This comprehensive guide will cover everything you need to know about Java 8 Streams, including their benefits, usage, and implementation. We will also answer some of the most commonly asked questions about Streams in Java.

What are Java 8 Streams?

Java 8 Streams are a sequence of elements that can be processed in parallel or sequential order. They allow the processing of data collections in a concise, expressive, and parallelized way. It provides a set of functional-style operations that can be applied to streams of elements, such as filtering, mapping, reducing, and sorting.

Streams can be created from various sources, such as collections, arrays, files, generators, and iterators. Once a stream is created, a pipeline of operations can be applied to it, resulting in a final stream that can be consumed or collected.

They are built on top of collections and provide a set of intermediate and terminal operations.

Intermediate operations transform a stream into another stream, while terminal operations return a result or a side effect. Streams can be processed in a sequential or parallel mode. In parallel mode, multiple threads can process the elements of the stream simultaneously, which can lead to significant performance improvements.

Java 8 Streams API

The Java 8 Streams API provides a set of functional interfaces, classes, and methods for creating, processing and manipulating streams. Some of the important classes and interfaces in the Streams API include:

- Stream: Represents a sequence of elements that can be processed sequentially or parallel.

- IntStream, LongStream, DoubleStream: Specialized streams for handling primitive data types.

- Collector: Performs a reduction operation on a stream and returns a result as a collection or a single value.

- Supplier: Provides a new instance of a collection or a stream.

- Predicate: Evaluates a boolean expression for a given input.

- Function: Applies a transformation on the input and returns a new output.

- Comparator: Compares two objects and returns a result.

How to Create a Stream in Java 8

Java 8 provides several ways to create a stream, depending on the data source. Here are some of the most common ways to create a stream in Java 8:

1. Creating an Empty Stream

In Java 8, you can create an empty stream using the Stream.empty() method. This method returns a sequential stream with no elements.

Stream emptyStream = Stream.empty();

Creating an empty stream can be useful in cases where you want to handle an empty collection gracefully or as a starting point for building a larger stream through concatenation or flatMap operations.

List list1 = Arrays.asList("apple", "banana", "orange");
List list2 = Collections.emptyList();

Stream stream = Stream.concat(list1.stream(), list2.stream());

stream.forEach(System.out::println); //Output: apple, banana, orange

2. Creating a Stream from a Collection

Create a stream from a collection: You can create a stream from any collection, such as List, Set, or Map using the Collections.stream() method. Here's an example:

List list = Arrays.asList("apple", "banana", "orange", "kiwi");
Stream stream = list.stream();

3. Creating a Stream from an Array

Create a stream from an array: You can create a stream from an array using the Arrays.stream() method. Here's an example:

int arr = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(arr);

4. Creating a Stream of Values

Create a stream of values: You can create a stream from a set of values using the Stream.of() method. Here's an example:

Stream stream = Stream.of("apple", "banana", "orange", "kiwi");

5. Creating a Stream from a File

Create a stream from a file: You can create a stream from a file using the Files.lines() method. Here's an example:

Path path = Paths.get("file.txt");
Stream stream = Files.lines(path);

6. Creating a Stream from a Primitive Value Range

It is also possible to create a stream from a range of values. For instance, you can create a stream from a range of values using the IntStream.range(int startInclusive, int endExclusive) or IntStream.rangeClosed() method.

The IntStream.range(int startInclusive, int endExclusive) method is used to create a sequential ordered stream of int values starting from startInclusive and ending at endExclusive - 1.

The IntStream.rangeClosed(int startInclusive, int endInclusive) method is used to create a sequential ordered stream of int values starting from startInclusive and ending at endInclusive.

Here's an example using IntStream.range() and IntStream.rangeClosed():

IntStream stream = IntStream.range(1, 5); // generates stream of 1, 2, 3, 4
IntStream stream2 = IntStream.rangeClosed(1, 5); // generates stream of 1, 2, 3, 4, 5

7. Creating a Stream using Stream.generate()

Create a stream from a generator: You can create an infinite stream using the Stream.generate() method.

The Stream.generate(Supplier s) method is used to create a sequential unordered stream where each element is generated by the provided Supplier. The Supplier functional interface generates the next value in the stream each time its get() method is called.

We can use a lambda expression to provide an implementation for the Supplier's get() method.

Stream.generate(() -> Math.random())
.limit(5)
.forEach(System.out::println);

8. Creating a Stream using an iterator

Create a stream from an iterator: You can create a stream from an iterator using the StreamSupport.stream() method. Here's an example:

Iterator iterator = Arrays.asList("apple", "banana", "orange", "kiwi").iterator();
Stream stream = StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false);

9. Creating a Stream using Stream.iterate()

The Stream.iterate(T seed, UnaryOperator f) method is used to create a sequential ordered stream where each element is generated by applying a function f to the previous element, starting with the seed element seed.

Stream stream = Stream.iterate(0, n -> n + 2)
.limit(5)
.forEach(System.out::println);

In summary, Java 8 provides a wide variety of options for creating streams, making it easy for developers to process data collections using a concise and efficient syntax.

Stream Referencing in Java 8

In Java 8, a stream is a one-time use object, which means you can't use it again once you've used it to perform intermediate and terminal operations. If you try to perform another operation on a stream that has already been closed, you'll get an IllegalStateException.

To reference a stream in Java 8, you simply create a new stream and assign it to a variable. For example, the following code creates a stream of integers and assigns it to the variable stream:

Stream stream = Stream.of(1, 2, 3, 4, 5);

Once you have a reference to a stream, you can perform intermediate and terminal operations on it as needed. However, you must be careful not to close the stream before you're finished with it. If you try to perform another operation on a closed stream, you'll get an IllegalStateException.

Here's an example of how to use a stream reference:

Stream stream = Stream.of(1, 2, 3, 4, 5);
stream.filter(n -> n % 2 == 0)
.forEach(System.out::println);

In the above example, we create a stream of integers and assign it to the variable stream. We then perform an intermediate operation using the filter() method to keep only the even numbers, and finally, we output the result using the forEach() method. Because we haven't closed the stream, we can use the stream reference to perform other operations if needed.

In summary, to reference a stream in Java 8, you simply create a new stream and assign it to a variable. However, be sure not to close the stream before you're finished with it, or you'll get an IllegalStateException if you try to perform another operation on it.

Stream Pipelining in Java 8

Stream pipelining in Java 8 refers to the process of chaining multiple stream operations together to form a pipeline. The output of one operation becomes the input of the next operation, allowing for complex data transformations to be performed on a stream of data.

In Java 8, streams have two types of operations: intermediate and terminal. Intermediate operations are operations that return a new stream, allowing for further operations to be performed. Terminal operations return a non-stream result, such as a primitive value or a collection.

Stream pipelining allows us to combine intermediate operations to form a single pipeline executed by calling a single terminal operation. This allows us to write concise, readable code while performing complex data transformations.

Here is an example of stream pipelining:

List numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()
.filter(n -> n % 2 == 0)
.mapToInt(Integer::intValue)
.sum();

In this example, we start with a list of integers and create a stream from it using the stream() method. We then chain together three intermediate operations: filter(), mapToInt(), and sum(). The filter() operation filters out any odd numbers, the mapToInt() operation converts the remaining even numbers to primitive integers, and the sum() operation calculates the sum of the resulting numbers. Finally, the sum() terminal operation returns the result of the entire pipeline, which is the sum of all even numbers in the list.

It's important to note that the operations in a stream pipeline are executed lazily. This means that the intermediate operations are not actually executed until a terminal operation is called. This allows for efficient processing of large data sets by only processing the data that is actually needed for the final result.

It's also important to optimize the order of operations in a pipeline. In the example above, the filter() operation is executed before the mapToInt() operation, which is executed before the sum() operation. Changing the order of these operations would result in a different result.

Stream Laziness

Laziness in Java 8 Streams is a key concept allowing streams to optimize and avoid unnecessary computations. In essence, laziness means that intermediate operations on a stream do not execute until a terminal operation is called.

This means that when we create a stream, nothing actually happens until we call a terminal operation like forEach(), reduce(), or collect(). Before that, all intermediate operations just create a pipeline that will be executed when a terminal operation is invoked.

For example, consider the following code:

List numbers = Arrays.asList(1, 2, 3, 4, 5);

Stream stream = numbers.stream()
.filter(n -> n % 2 == 0)
.map(n -> n * n);

stream.forEach(System.out::println);

In this code, we create a stream from a list of integers and apply two intermediate operations: filter() and map(). However, nothing happens until we call the terminal operation forEach().

This laziness allows Java 8 Streams to optimize performance by avoiding unnecessary computations. For example, if we have a large data set and we only need the first 10 elements of a stream, we don't need to process the entire data set before we can access those elements. Instead, we can stop processing the stream as soon as we get the 10 elements we need.

In addition, laziness allows us to chain multiple intermediate operations together, creating a pipeline that can be optimized and executed more efficiently. For example, we can filter a stream before mapping it, reducing the number of elements that need to be mapped.

Overall, laziness is a powerful feature of Java 8 Streams that allows for efficient and optimized stream processing.

The Importance of Operation Order in Streams

To best illustrate the importance of operation and execution order in streams, let's alter the previous example to the following:

List numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream().filter(n -> n % 2 == 0)
.map(n -> n * 2)
.forEach(System.out::println); //Output: 4, 8

numbers.stream().map(n -> n * 2)
.filter(n -> (n / 2) % 2 == 0)
.forEach(System.out::println); //Output: 4, 8

In the above code example, both statements will print the same output:

4
8

However, the second statement is suboptimal because it involves more computation than the first statement.

In the first statement, the filter() operation is applied before the map() operation. This is beneficial because the filter() operation eliminates half of the elements in the stream before the map() operation doubles the remaining elements. Therefore, the map() operation will only have to perform half the number of computations it would have to perform if it was applied to all the elements in the stream.

On the other hand, the second statement applies the map() operation before the filter() operation. This means that the map() operation will be applied to all elements in the stream, even though the subsequent filter() operation will eliminate some of them. This results in unnecessary computation, which can slow down the performance of the code.

Therefore, it is recommended to apply the filter() operation before the map() operation to optimize the performance of the code by reducing the stream's size.

Intermediate Operations in Java 8 Streams

Intermediate operations in Java 8 Streams transform a stream into another stream. These operations are lazy, meaning they do not execute until a terminal operation is called. Some of the important intermediate operations in Java 8 Streams include:

- filter(): Filters the elements of a stream based on a given predicate.

- map(): Transforms each stream element to another element using a given function.

- flatMap(): Flattens a stream of streams into a single stream.

- distinct(): Removes duplicate elements from a stream.

- sorted(): Sorts the elements of a stream based on a given comparator.

- peek(): Applies a function to each stream element and returns a new stream.

- skip(): Discards the first n elements of a stream.

- limit(): Returns a stream that is no longer than the request size n.

1. Stream filter() operator

Stream filter(Predicate
https://borderpolar.com/java-8-streams-api-tutorial/