Stream In Java

Stream in Java was introduced in Java 8 to simplify the processing of collections and data. It provides a modern and efficient way to perform operations on groups of objects using a functional programming approach. Streams help developers write cleaner, shorter, and more readable code for data processing tasks.

• Allows processing of data without modifying the original collection.
• Supports parallel processing to improve performance on large datasets.
• Reduces the need for lengthy loops and temporary variables in code.

How to Create a Java Stream

Java Stream Creation is one of the most basic steps before considering the functionalities of the Java Stream. Below is the syntax given for declaring a Java Stream.

Syntax

Stream<T> stream;

Stream<T>: general object stream for reference types

Java Stream Features

The features of Java streams are mentioned below:

• A Stream is not a data structure; it just takes input from Collections, Arrays or I/O channels.
• Streams do not modify the original data; they only produce results using their methods.
• Intermediate operations (like filter, map, etc.) are lazy and return another Stream, so you can chain them together.
• A terminal operation (like collect, forEach, count) ends the stream and gives the final result.

Different Operations On Streams

There are two types of Operations in Streams:

1. Intermediate Operations

Intermediate operations are the operations that transform a stream into another stream. These operations are lazy in nature, meaning they do not execute until a terminal operation is called.

👁 Java Stream Operations

Intermediate Operations are the types of operations in which multiple methods are chained in a row.

Characteristics of Intermediate Operations

• Methods are chained together.
• Intermediate operations transform a stream into another stream.
• It enables the concept of filtering where one method filters data and passes it to another method after processing.

Important Intermediate Operations

There are a few Intermediate Operations mentioned below:

1. map(): The map method is used to return a stream consisting of the results of applying the given function to the elements of this stream.

Syntax:

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

2. filter(): The filter method is used to select elements as per the Predicate passed as an argument.

Syntax:

Stream<T> filter(Predicate<? super T> predicate)

3. sorted(): The sorted method is used to sort the stream.

Syntax:

Stream<T> sorted()
Stream<T> sorted(Comparator<? super T> comparator)

4. flatMap(): The flatMap operation in Java Streams is used to flatten a stream of collections into a single stream of elements.

Syntax:

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

5. distinct(): Removes duplicate elements. It returns a stream consisting of the distinct elements (according to Object.equals(Object)).

Syntax:

Stream<T> distinct()

6. peek(): Performs an action on each element without modifying the stream. It returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.

Syntax:

Stream<T> peek(Consumer<? super T> action)

Example: Program that demonstrates the use of all the intermediate operations:

Intermediate Results:
STRUCTURE
STREAM
STATE
SORTING
Final Result:
SORTING
STATE
STREAM
STRUCTURE

Explanation:

• The listOfLists is created as a list containing other lists of strings.
• flatMap(List::stream): Flattens the nested lists into a single stream of strings.
• filter(s -> s.startsWith("S")): Filters the strings to only include those that start with "S".
• map(String::toUpperCase): Converts each string in the stream to uppercase.
• distinct(): Removes any duplicate strings.
• sorted(): Sorts the resulting strings alphabetically.
• peek(...): Adds each processed element to the intermediateResults set for intermediate inspection.
• collect(Collectors.toList()): Collects the final processed strings into a list called result.

The program prints the intermediate results stored in the intermediateResults set. Finally, it prints the result list, which contains the fully processed strings after all stream operations.

2. Terminal Operations

Terminal operations are the operations that produce the final result from a stream and end the stream processing. These operations trigger the execution of all intermediate operations.

These Operations are not processed further just return a final result value.

Important Terminal Operations

1. collect(): The collect method is used to return the result of the intermediate operations performed on the stream.

Syntax:

<R, A> R collect(Collector<? super T, A, R> collector)

2. forEach(): The forEach method is used to iterate through every element of the stream.

Syntax:

void forEach(Consumer<? super T> action)

3. reduce(): The reduce method is used to reduce the elements of a stream to a single value. The reduce method takes a BinaryOperator as a parameter.

Syntax:

T reduce(T identity, BinaryOperator<T> accumulator)
Optional<T> reduce(BinaryOperator<T> accumulator)

4. count(): Returns the count of elements in the stream.

Syntax:

long count()

5. findFirst(): Returns the first element of the stream, if present.

Syntax:

Optional<T> findFirst()

6. allMatch(): Checks if all elements of the stream match a given predicate.

Syntax:

boolean allMatch(Predicate<? super T> predicate)

7. anyMatch(): Checks if any element of the stream matches a given predicate.

Syntax:

boolean anyMatch(Predicate<? super T> predicate)

Here ans variable is assigned 0 as the initial value and i is added to it.

Example: Program Using all Terminal Operations

Output:

Explanation:

• The names list is created with sample strings.
• forEach: Prints each name in the list.
• collect: Filters names starting with 'S' and collects them into a new list.
• reduce: Concatenates all names into a single string.
• count: Counts the total number of names.
• findFirst: Finds and prints the first name in the list.
• allMatch: Checks if all names start with 'S'.
• anyMatch: Checks if any name starts with 'S'.

The program prints each name, names starting with 'S', concatenated names, the count of names, the first name, whether all names start with 'S' and whether any name starts with 'S'.

Intermediate Operations are running based on the concept of Lazy Evaluation, which ensures that every method returns a fixed value(Terminal operation) before moving to the next method.

Filtering: Aman
Filtering: Sita
Mapping: Sita
First name starting with 'S': SITA

Explanation: Intermediate operations in a stream (like filter and map) are lazy and process elements one by one only when a terminal operation (like findFirst) is invoked, allowing early termination and efficient execution.

Benefit of Java Stream

There are some benefits because of which we use Stream in Java as mentioned below:

• No storage
• Pipeline of functions
• Laziness
• Can be infinite
• Can be parallelized for large datasets (may not always improve performance)
• More readable and concise than loops
• Can be created from collections, arrays, files, methods, IntStream, etc.

Streams are widely used in modern Java applications for:

• Data Processing
• For processing JSON/XML responses
• For database Operations
• Concurrent Processing

Intermediate Operation vs Terminal Operation