Java | Streams and pipelines

In Java 8, the Stream API was introduced as a powerful and efficient way to work with collections of data. Streams provide a functional way to perform bulk operations on a collection of data and can be used to process large datasets efficiently. In this article, we will cover the basics of streams and pipelines in Java, including examples of how to use them in your code.

What are Streams?

In Java, a Stream is a sequence of elements that can be processed in a functional way. Streams allow you to perform operations on a collection of data without modifying the original data structure. This makes them ideal for working with large datasets or when you need to perform multiple operations on the same dataset. Streams are similar to iterators, but with a functional programming approach.

Streams provide two types of operations: intermediate and terminal. Intermediate operations return a new stream and can be chained together to create a pipeline of operations. Terminal operations produce a result or a side effect and end the pipeline.

Intermediate Operations:

Here are some common intermediate operations that can be performed on a stream:

filter(Predicate<T> predicate) – Returns a stream consisting of the elements that match the given predicate.
map(Function<T, R> mapper) – Returns a stream consisting of the results of applying the given function to the elements of this stream.
flatMap(Function<T, Stream<R>> mapper) – Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
distinct() – Returns a stream consisting of the distinct elements of this stream.

Terminal Operations:

Here are some common terminal operations that can be performed on a stream:

forEach(Consumer<T> action) – Performs an action for each element of this stream.
count() – Returns the count of elements in this stream.
max(Comparator<T> comparator) – Returns the maximum element of this stream according to the provided comparator.
min(Comparator<T> comparator) – Returns the minimum element of this stream according to the provided comparator.
reduce(T identity, BinaryOperator<T> accumulator) – Returns the result of the given accumulator function applied to the elements of this stream.

Example:

Let’s take a look at an example of how to use these stream operations in Java. Suppose we have a list of strings and we want to find the number of characters in each string.

List<String> names = Arrays.asList("Bob", "Charlie", "David", "Eve");
names.stream()
     .map(String::length)
     .forEach(System.out::println);

In this example, we first create a list of strings. We then convert the list to a stream using the stream() method. We map each string to its length using the map() method, and finally, we print the length of each string using the forEach() method.

The output of this program will be:

In this example, we used the map() and forEach() methods to create a pipeline of operations that were applied to the stream. The pipeline is ended with the forEach() method, which prints the final result.

Conclusion:

Streams and pipelines are powerful and efficient tools for working with collections of data in Java. They allow you to perform bulk operations on a collection of data without modifying the original data structure. This makes them ideal for working with large datasets or when you need to perform multiple operations on the same dataset. By mastering the Stream API, you can write more efficient and maintainable code in Java.

Leave a Reply Cancel reply