4 questions on Java 8 Streams

java.util.stream (which was added in Java8) is composed of classes that enables processing stream of elements.

1.What is a stream?

A stream is a flow of objects that we can apply methods on to create the results we want. As it was stated here, it is not a data structure to store the elements. You create it, you make it go through a pipeline of computational operations, you get the results you want, it’s closed and that’s it.

One of the key properties of streams is it doesn’t change and manipulate the original source.

2. How to create a stream?

In order to create a stream, stream() or parallelStream() functions which are implemented in Collection interface (as default) can be used and they create a stream with the collection this method called on as the source.

List<Integer> list = new ArrayList<Integer>();Stream<Integer> stream = evens.stream();

2. What kind of operations can we have on streams?

There are two kinds of operations that can be applied on streams:

a. Intermediate operations: These operations turns streams to other streams and create an operation pipeline. They don’t get executed unless there is a terminal operation called on the stream, which is our next kind of operation.

Intermediate operation examples include filter, map, distinct, limit, skip, sorted and peek functions.

List<String> names = new ArrayList<String>(Arrays.asList("alex", "brian", "charles"));Stream<String> = names.stream()

b. Terminal operations: These operations produce the result we want from the stream, and can’t be used to continue the chain. Streams can’t be reused after a terminal operation is called in the chain, stream is closed.

List<Integer> list = new ArrayList<Integer>(Arrays.asList(1,3,5,7,9));Stream<Integer> stream = list.stream();//Terminal operation is called
//Intermediate operation gives a java.lang.IllegalStateException stream.filter(s -> s > 5);

This exception occur for two reasons. First, a terminal operation is called on it and stream is closed. Secondly, even if an intermediate operation was called instead of foreach function, since the state of stream has changed, we cannot invoke a method on the changed stream outside of the operation pipeline.

Most stream operations accept lambda expressions and functional interfaces as parameter. These operations must be both non-interfering (meaning they don’t change the underlying source) and stateless ( which is deterministic ).

3. Why use streams?

One of the first questions that came to my mind while learning about streams was “Why would I use streams while I can do the same things using for loops and whatnot?”. The answer is in this sentence:

A key driver for this work is making parallelism more accessible to developers.

It was written by Brian Goetz in his article on Java 8 streams. Using parallel streams allow developers to execute these functions in parallel and enhances the performance. The key is performance.

* Operation pipeline: Chain of stream operations

** Functional interface: interfaces with exactly one abstract method. (They can have other default methods, though.) Details can be found here.




a geek who loves to understand the reasons behind things... and colors... Colors are cool.

Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

733. Flood Fill

LeetCode Reverse Integer


Finding a Few Bright Lights in 2020 — Highlights from Team Artemis

Building a co-occurrence matrix with d3 to analyze overlapping topics in dissertations

Maximize ROI with Cubewise

Building a static web blog with Jekyll and GitHub Pages / Local Machine

The Ultimate Checklist for Salesforce Data Migration

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Mehmet Akcay

Mehmet Akcay

a geek who loves to understand the reasons behind things... and colors... Colors are cool.

More from Medium

Compilation and Execution of Java Program

Factory Method Design Pattern Explained.

Polymorphism in a Nutshell

“String in Java is immutable” is it right?