Java 8 Stream - Terminal Operations With Examples

Hi All,

Greeting of the day!

Today we will explore terminal operations of stream in java 8 which are most frequently used. So let's start.

What are terminal operations - Terminal operations are stream operations which return the void or non-stream results instead of another stream hence called terminal operations.

Terminal operations are applied after intermediate operations.

Below are important terminal operations

• Stream.count()
• Stream.min()
• Stream.max()
• Stream.anyMatch()
• Stream.allMatch()
• Stream.collect()
• Stream.forEach()

We will take consider below Book class and the list of books to apply all terminal operations.

Book.java

package com.demo; public class Book { private int bookId; private String bookName; private int bookPrice; public Book(int bookId, String bookName, int bookPrice) { super(); this.bookId = bookId; this.bookName = bookName; this.bookPrice = bookPrice; } public int getBookId() { return bookId; } public void setBookId(int bookId) { this.bookId = bookId; } public String getBookName() { return bookName; } public void setBookName(String bookName) { this.bookName = bookName; } public int getBookPrice() { return bookPrice; } public void setBookPrice(int bookPrice) { this.bookPrice = bookPrice; } @Override public String toString() { return "Book [bookId=" + bookId + ", bookName=" + bookName + ", bookPrice=" + bookPrice + "]"; } }

So let's explore the above operations in detail.

Stream.count() returns no of the element in stream, in the below example we will use an intermediate operation filter on the input stream, and then we will use the terminal operation to count the element present after filtering.

long count();

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, "Introduction to java", 575); Book b2 = new Book(1, "REST With Spring", 800); Book b3 = new Book(1, "Spring Security", 755); List<Book> books = new ArrayList<>(); books.add(b1); books.add(b2); books.add(b3); long totalSpringBooks = books.stream().filter(x -> x.getBookName().contains("Spring")).count(); System.out.println("Total available books of spring " + totalSpringBooks); } }

O/P Total available books of spring  2

Stream.min() - is a terminal operation used to find a minimum element from the input stream.

Optional<T> min(Comparator<? super T> comparator);

As you can see we need to pass a comparator for comparing all elements of the stream. In the below example, we are finding the cheapest book from all books.

package com.demo; import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.Optional; public class Test { public static void main(String[] args) { Book b1 = new Book(1, "Introduction to java", 575); Book b2 = new Book(1, "REST With Spring", 800); Book b3 = new Book(1, "Spring Security", 755); List<Book> books = new ArrayList<>(); books.add(b1); books.add(b2); books.add(b3); Optional<Book> cheapestPriceBook = books.stream().min(Comparator.comparing(Book::getBookPrice)); System.out.println(cheapestPriceBook.get()); } }

O/P Book - [bookId=1, bookName=Introduction to java, bookPrice=575]

Stream.max() - is a terminal operation used to find the maximum element from the input stream.

Optional<T> max(Comparator<? super T> comparator);

package com.demo; import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.Optional; public class Test { public static void main(String[] args) { Book b1 = new Book(1, "Introduction to java", 575); Book b2 = new Book(1, "REST With Spring", 800); Book b3 = new Book(1, "Spring Security", 755); List<Book> books = new ArrayList<>(); books.add(b1); books.add(b2); books.add(b3); Optional<Book> costliestBook = books.stream().max(Comparator.comparing(Book::getBookPrice)); System.out.println(costliestBook.get()); } }

O/P - Book [bookId=1, bookName=REST With Spring, bookPrice=800]

Stream.anyMatch()- is a terminal operation returning a boolean value, i.e true if the stream contains any element that matches the given predicate.

boolean anyMatch(Predicate<? super T> predicate); 

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, "Introduction to java", 575); Book b2 = new Book(1, "REST With Spring", 800); Book b3 = new Book(1, "Spring Security", 755); List<Book> books = new ArrayList<>(); books.add(b1); books.add(b2); books.add(b3); boolean restAPIBookExists = books.stream().anyMatch(x -> x.getBookName().equalsIgnoreCase("REST With Spring")); System.out.println("List contains Rest API Book ::" + restAPIBookExists); } }

O/P -  List contains Rest API Book::true

Stream.allMatch() - is a terminal operation that returns true when all elements of the stream match the given predicate.

boolean allMatch(Predicate<? super T> predicate);

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, "Introduction to java", 575); Book b2 = new Book(1, "REST With Spring", 800); Book b3 = new Book(1, "Spring Security", 755); List<Book> books = new ArrayList<>(); books.add(b1); books.add(b2); books.add(b3); boolean priceOfBooks = books.stream().allMatch(x -> x.getBookPrice() > 600); System.out.println("Price of all books is greater then 600 " + priceOfBooks); } }

O/P - Price of all books is greater than 600 false

Stream.collect() - is used to collect elements back after applying other intermediate operations.

Example

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, "Introduction to java", 575); Book b2 = new Book(2, "REST With Spring", 800); Book b3 = new Book(3, "Spring Security", 755); List<Book> books = new ArrayList<>(); books.add(b1); books.add(b2); books.add(b3); List<Book> books2= books.stream().limit(2).collect(Collectors.toList()); System.out.println(books2); } }

O/P [Book [bookId=1, bookName=Introduction to java, bookPrice=575], Book [bookId=2, bookName=REST With Spring, bookPrice=800]]

Stream.forEach() - is used to iterate elements of the stream and perform any operation on each element.

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, "Introduction to java", 575); Book b2 = new Book(2, "REST With Spring", 800); Book b3 = new Book(3, "Spring Security", 755); List<Book> books = new ArrayList<>(); books.add(b1); books.add(b2); books.add(b3); books.stream().forEach(x->System.out.println(x.getBookName().toUpperCase())); } }

O/P

INTRODUCTION TO JAVA

REST WITH SPRING

SPRING SECURITY

So we have covered most of the terminal operations of the stream, let me know if you have any questions.

You can refer below useful post

Java 8 Stream - Intermediate Operations With Examples

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

Statement + Prepared Statement + Callable Statement In Java

Comparator and Comparable In Java + Difference Between Comparator and Comparable + Java 8

Sorting HashMap By Key And Value + Java 8

For spring visit Spring Tutorial

Thanks

Happy Learning!