Java Stream API

Java provides a new additional package in Java 8 called java.util.stream. This package consists of classes, interfaces and enum to allows functional-style operations on the elements. You can use stream by importing java.util.stream package.

Stream provides following features:

• Stream does not store elements. It simply conveys elements from a source such as a data structure, an array, or an I/O channel, through a pipeline of computational operations.
• Stream is functional in nature. Operations performed on a stream does not modify it's source. For example, filtering a Stream obtained from a collection produces a new Stream without the filtered elements, rather than removing elements from the source collection.
• Stream is lazy and evaluates code only when required.
• The elements of a stream are only visited once during the life of a stream. Like an Iterator, a new stream must be generated to revisit the same elements of the source.

We can use stream to filter, collect, print, and convert from one data structure to other etc. In the following examples, we have applied various operations with the help of stream.

Various Core Operations Over Streams

1. Intermediate Operations

Intermediate operations in Java Streams return another Stream. They are typically used to transform or filter the elements of the original Stream. Since they are lazy, meaning they do not perform any processing until a terminal operation is called, multiple intermediate operations can be chained together.

Common Intermediate Operations:

• map(Function<T, R>): Transforms each element of the Stream into another form using the provided function.
• filter(Predicate<T>): Selects elements from the Stream based on a specified condition.
• flatMap(Function<T, Stream<R>>): Transforms each element into zero or more elements by applying a function that returns a stream for each element.
• distinct(): Removes duplicate elements from the Stream.
• sorted(): Sorts the elements of the Stream.
• limit(long n): Truncates the Stream to be no longer than the specified size.
• skip(long n): Skips the first n elements of the Stream.
• peek(Consumer<T>): Performs a specified action on each element of the Stream without consuming the elements.

2. Terminal Operations

Terminal operations are those operations that consume the Stream and produce a result, such as a value, a collection, or even a side effect. Once a terminal operation is invoked, the Stream is processed and cannot be reused.

Common Terminal Operations:

• forEach(Consumer<T>): Acts as each element of the Stream.
• collect(Collector<T, A, R>): Reduces the elements of the Stream into a mutable result container, such as a list or a map.
• reduce(BinaryOperator<T>): Reduces the elements of the Stream to a single value using an associative accumulation function.
• count(): Returns the count of elements in the Stream.
• anyMatch(Predicate<T>): Returns true if any element of the Stream matches the given predicate.
• allMatch(Predicate<T>): Returns true if all elements of the Stream match the given predicate.
• noneMatch(Predicate<T>): Returns true if no elements of the Stream match the given predicate.
• findFirst(): Returns an Optional describing the first element of the Stream, or an empty Optional if the Stream is empty.
• findAny(): Returns an Optional describing some element of the Stream, or an empty Optional if the Stream is empty.

3. Short-Circuit Operations

Short-circuit operations are a subset of terminal operations that do not need to process the entire Stream to produce a result. They can provide an early exit from the stream processing pipeline, potentially saving computation time.

Common Short-Circuit Operations:

• anyMatch(Predicate<T>): Stops processing and returns true if any element matches the given predicate.
• allMatch(Predicate<T>): Stops processing and returns false if any element does not match the given predicate.
• noneMatch(Predicate<T>): Stops processing and returns true if no elements match the given predicate.
• findFirst(): Returns the first element encountered in the Stream and then stops processing.
• findAny(): Returns any element encountered in the Stream and then stops processing.

Java Stream Interface Methods

Java Example: Filtering Collection without using Stream

In the following example, we are filtering data without using stream. This approach we are used before the stream package was released.

Output:

[25000.0, 28000.0, 28000.0]

Java Stream Example: Filtering Collection by Using Stream

Here, we are filtering data by using stream. We can see that code is optimized and maintained. Stream provides fast execution.

Output:

[90000.0]

Java Stream Iterating Example

We can use stream to iterate any number of times. Stream provides predefined methods to deal with the logic we implement. In the following example, we are iterating, filtering and passed a limit to fix the iteration.

Output:

5
10
15
20
25

Java Stream Example: Filtering and Iterating Collection

In the following example, we are using filter() method. Here, we can see code is optimized and very concise.

Output:

Dell Laptop

Java Stream Example : reduce() Method in Collection

This method takes a sequence of input elements and combines them into a single summary result by repeated operation. For example, finding the sum of numbers, or accumulating elements into a list.

In the following example, we are using reduce() method, which is used to sum of all the product prices.

Output:

201000.0
201000.0

Java Stream Example: Sum by Using Collectors Methods

We can also use collectors to compute sum of numeric values. In the following example, we are using Collectors class and it's specified methods to compute sum of all the product prices.

Output:

201000.0

Java Stream Example: Find Max and Min Product Price

Following example finds min and max product price by using stream. It provides convenient way to find values without using imperative approach.

Output:

90000.0
25000.0

Java Stream Example: count() Method in Collection

Output:

3

Stream allows us to collect result in any various forms. We can get you result as set, list or map and can perform manipulation on the elements.

Java Stream Example : Convert List into Set

Output:

[25000.0, 28000.0]

Java Stream Example: Convert List into Map

Output:

{1=HP Laptop, 2=Dell Laptop, 3=Lenevo Laptop, 4=Sony Laptop, 5=Apple Laptop}

Method Reference in stream

Output:

[90000.0]

Java Stream Specializations

Java Streams API offers specialized stream types for handling primitive data types efficiently: IntStream for integers, LongStream for long integers, and DoubleStream for doubles. These specializations provide enhanced performance and are equipped with additional operations tailored for numerical computation, making them highly suitable for operations involving primitive numbers.

1. Specialized Operations

Specialized streams come with operations that are particularly useful when working with numeric data. These operations extend beyond those available in the generic Stream <T> interface, offering methods that facilitate arithmetic computations directly on streams of primitives.

2. Reduction Operations

Reduction operations are a type of terminal operation that combines all elements of the Stream into a single result. These operations use a binary operator to repeatedly apply a function, carrying forward the result as the first argument of the operator for each subsequent application of the function to the next stream element. This pattern is especially powerful for summarizing or aggregating numerical data.

Java Stream: File Operation

Java Streams API, introduced in Java 8, provides a very efficient and expressive way to handle streams of data, including files. In this context, the term "streams" refers to a sequence of elements supporting sequential and parallel aggregate operations, not to be confused with InputStream and OutputStream from I/O streams.

Using the Streams API to manipulate file data involves reading from files, processing the data line-by-line or in bulk, and often writing results to another file. It is typically achieved using the Files class in the java.nio.file package, which integrates seamlessly with the Streams API.

Input:

Output:

Read line: hello
Read line: world
Read line: Yes
Read line: 12345
Read line: Spaces
Read line: Java!
Read line: 1234
Read line: ABCDE
Filtered strings with length 5 (converted to uppercase): [HELLO, WORLD, 12345, JAVA!, ABCDE]

Output:

Text has been successfully written to the file.