Java 8 Stream - Intermediate Operations With Examples

Hi All,

Today we will look at stream intermediate operations using Java 8.

So let's get started.

What are intermediate operations? Intermediate operations are stream operations that return another stream, allowing us to chain several stream operations together.

What are terminal operations? Terminal operations are stream operations that return void or non-stream results, hence it's called terminal operations.

Intermediate Operations 

• Intermediate operations are always lazy, which means they are not evaluated until the terminal operation is called.
• Intermediate operations are further classified as stateless and stateful.
• Stateless operations do not keep the state of a previously seen element, implying that each element of a stream is processed independently. Filter and map as examples
• Stateful operations - keep a previously seen element's state. Before producing output, these operations must process the entire stream. Distinct and sorted examples

Below are some of the intermediate operations.

• Stream.filter()
• Stream.map()
• Stream..sorted()
• Stream.skip()
• Stream.limit()
• Stream.distinct()
• Stream.flatMap()

Stream.filter() - is an intermediate operator that returns all elements that match a given condition as specified by the predicate argument.

Because a predicate is a functional interface, we can pass a lambda expression as well.

The filter method's syntax is shown below.

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

So let's look at an example to better understand filter.

package com.demo; import java.util.ArrayList; import java.util.List; import java.util.function.Predicate; import java.util.stream.Collectors; public class Test { public static void main(String[] args) { Book b1 = new Book(1, "Java 8", 400); Book b2 = new Book(2, "Spring REST API", 500); Book b3 = new Book(3, "Data structure & algorithm", 600); List<Book> books = new ArrayList<Book>(); books.add(b1); books.add(b2); books.add(b3); System.out.println("Filter books having price greater than 500 using instance of predicate"); books.stream().filter(new Predicate<Book>() { @Override public boolean test(Book t) { return t.getBookPrice() > 500; }}).collect(Collectors.toList()) .forEach(System.out::println); System.out.println("Filter books having price greater than 400 using lamda expression"); books.stream() .filter(x -> x.getBookPrice() > 400) .collect(Collectors.toList()) .forEach(System.out::println); } }

So here we have taken an example of the filter by implementing Predicate and a lambda expression.

O/P

Filter books having price greater than 500 using instance of predicate Book [bookId=3, bookName=Data structure & algorithm, bookPrice=600] Filter books having price greater than 400 using lamda expression Book [bookId=2, bookName=Spring REST API, bookPrice=500] Book [bookId=3, bookName=Data structure & algorithm, bookPrice=600]

 

Stream.map() -It's intermediate and lazy in nature, and it's used to apply any function to each element of the stream.

Let's look at an example to better understand the map. Here, we will apply a 10% discount to each book and convert the title to upper case.

package com.demo; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; public class Test { public static void main(String[] args) { Book b1 = new Book(1, "Java 8", 400); Book b2 = new Book(2, "Spring REST API", 500); Book b3 = new Book(3, "Data structure & algorithm", 600); List<Book> books = new ArrayList<Book>(); books.add(b1); books.add(b2); books.add(b3); books.stream().map(x -> x.getBookPrice() - x.getBookPrice() * 0.1) .collect(Collectors.toList()) .forEach(System.out::println); books.stream().map(x -> x.getBookName().toUpperCase()) .collect(Collectors.toList()) .forEach(System.out::println); } }

O/P

360.0 450.0 540.0 JAVA 8 SPRING REST API DATA STRUCTURE & ALGORITHM

Stream.sorted() -is an intermediate operation used to sort streams in ascending and descending order; we must pass an instance of comparator as shown below for a list of custom objects.

We must use a reversed method to sort in descending order.

Example

package com.demo; import java.util.ArrayList; import java.util.Comparator; import java.util.List; public class Test { public static void main(String[] args) { Book b1 = new Book(1, "Java 8", 400); Book b2 = new Book(2, "Spring REST API", 500); Book b3 = new Book(3, "Data structure & algorithm", 600); List<Book> books = new ArrayList<Book>(); books.add(b1); books.add(b2); books.add(b3); System.out.println("Sorting books in descending order"); books.stream() .sorted(Comparator.comparingInt(Book::getBookId).reversed()) .forEach(System.out::println); System.out.println("Sorting integers in ascending order"); List<Integer> integers = new ArrayList<>(); integers.add(3); integers.add(2); integers.add(5); integers.add(1); integers.stream() .sorted().forEach(System.out::println); } }

O/P

Sorting books in descending order Book [bookId=3, bookName=Data structure & algorithm, bookPrice=600] Book [bookId=2, bookName=Spring REST API, bookPrice=500] Book [bookId=1, bookName=Java 8, bookPrice=400] Sorting integers in ascending order 1 2 3 5

Stream.skip()-is an intermediate operation that skips the first n elements of a stream; the parameter n must be positive, and if n exceeds the size of the stream, it returns an empty stream.

package com.demo; import java.util.ArrayList; import java.util.List; public class Test { public static void main(String[] args) { Book b1 = new Book(1, "Java 8", 400); Book b2 = new Book(2, "Spring REST API", 500); Book b3 = new Book(3, "Data structure & algorithm", 600); List<Book> books = new ArrayList<Book>(); books.add(b1); books.add(b2); books.add(b3); System.out.println("Skipping first element from books"); books.stream().skip(1).forEach(System.out::println); } }

O/P

Skipping first element from books Book [bookId=2, bookName=Spring REST API, bookPrice=500] Book [bookId=3, bookName=Data structure & algorithm, bookPrice=600]

Stream.limit(n) - is an intermediate operation that returns a stream of size n, where n cannot be negative.

Example

package com.demo; import java.util.ArrayList; import java.util.List; public class Test { public static void main(String[] args) { Book b1 = new Book(1, "Java 8", 400); Book b2 = new Book(2, "Spring REST API", 500); Book b3 = new Book(3, "Data structure & algorithm", 600); List<Book> books = new ArrayList<Book>(); books.add(b1); books.add(b2); books.add(b3); System.out.println("Getting 2 element from books "); books.stream().limit(2).forEach(System.out::println); } }

O/P

Getting 2 element from books Book [bookId=1, bookName=Java 8, bookPrice=400] Book [bookId=2, bookName=Spring REST API, bookPrice=500]

Stream.distinct() - returns a stream containing a single distinct element from the given input stream It's an intermediate stateful operation. To find distinct elements, it employs the equals method.

package com.demo; import java.util.Arrays; import java.util.List; public class Test { public static void main(String[] args) { List<Integer> integers= Arrays.asList(1, 3, 4, 2, 1, 4, 7); System.out.println("Finding distinct elements "); integers.stream().distinct().forEach(System.out::println); } }

O/P

1

3

4

2

7

Stream.flatMap()- It is an intermediate operation used for flattening + mapping. We've already seen mapping used above.

Flattening - is used to make the List flat.

Example Converting  List<List<String >> to List<String>

Or List<List<List<String >>> to List<List<String >>

Example 

Here we add 2 lists inside List<List<String>> and we will then flat them to a single List<String>

package com.demo; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; public class Test { public static void main(String[] args) { List<String> strings = new ArrayList<String>(); strings.add("Rajesh"); strings.add("Pratik"); List<String> string1 = new ArrayList<String>(); strings.add("Suresh"); strings.add("Akash"); List<List<String>> lists = new ArrayList<>(); lists.add(strings); lists.add(string1); List<String> flatList = lists.stream() .flatMap(x -> x.stream()) .collect(Collectors.toList()); System.out.println(flatList); } }

O/P

[Rajesh, Pratik, Suresh, Akash]

So far, we've covered the majority of the intermediate operators in Java 8.

Please let me know if you have any further questions.

Thanks

Enjoy your learning!

You can refer to this helpful post.

Java 8 Stream - Terminal Operations With Examples

Java Interview Programs - Count No Of Occurrences Of Element In List + Find Duplicate Elements In List + Java 8

Sorting HashMap By Key And Value + Java 8

Sorting HashSet In Ascending & Descending order + Java 8

For spring visit Spring Tutorial