In this blog, I am going to explore the difference between using streams and loops and how we can manage the maintainability of the code.
There are many opinions regarding the performance of both the things that which one is better streams or loops.
As we know, A stream is a sequence of objects that supports various methods which can be pipe-lined to produce the desired result.
Streams bring functional programming in Java and Java provides a new additional package in Java 8 called java.util.stream.
This package consists of classes, interfaces, and enum to allow functional-style operations on the elements.
You can use stream by importing java. util.stream package.
Looping in programming languages is a feature that facilitates the execution of a set of instructions/functions repeatedly while some condition evaluates to true.
Which is better stream or loop?
It all depends on what you want your application to do.
If raw performance is your No 1 priority, then maybe you are better off with loops.
But most people don’t want raw performance as their top priority.
Remember that loops use an imperative style and Streams a declarative style, so Streams are likely to be much easier to maintain.
If you have a small list, loops perform better.
If you have a huge list, a parallel stream will perform better.
Purely thinking in terms of performance, you shouldn’t use a for-each loop with an ArrayList, as it creates an extra Iterator instance that you don’t need (for LinkedList it’s a different matter).
However, this is a case of premature optimization. You may win several nanoseconds by making your code less easy to read.
Example:
Features:
The features of the Java stream are –
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 do not modify the 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 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
Example:
Let us now explore the for a loop now,
For loop is an entry-controlled loop and it follows:
The initialization expression initializes the loop control variable and is executed only once when the loop starts.
It’s optional and can be omitted by just putting a semicolon.
The conditional expression tested at the start of each iteration of the loop.
Loop will iterate as long as this condition remains true.
The increment/decrement expression updates the loop control variable after each iteration.
The body of the loop consists of the statements that need to be repeatedly executed.
Example:
Advantages:
Advantages of the streams:
Streams encourage less mutability.
Streams provide the most convenient and natural way to apply functions to sequences of objects.
Your stream-handling code doesn’t need to know the source of the stream or its eventual terminating method.
Streams can succinctly express quite sophisticated behavior.
Streams can be a replacement for looping because they allow for the processing of a sequence of data (similarly to a loop).
Advantages of the loops:
Using loops, we do not need to write the same code again and again.
The world is full of experienced procedural programmers, from many language backgrounds, for whom loops are familiar and streams are novel. In some environments, you want to write code that’s familiar to that kind of person.
Cognitive overhead: Because of its declarative nature, and increased abstraction from what’s happening underneath, you may need to build a new mental model of how code relates to execution.
Actually, you only need to do this when things go wrong, or if you need to deeply analyze performance or subtle bugs.
When it “just works”, it just works.
Conclusion:
Functional programming is very interesting from a performance standpoint.
Functional code often declares what final result you want to achieve, without specifying how to achieve it.
To reduce maintenance costs of your projects, please do consider using the Stream API instead of for loops.
