Hello readers, this tutorial explains the concept ofreducing andcollecting in Streams and Collector’s API respectively.

1. Introduction

1.1 Stream’s reduce() Method

Let’s take a look at the Streams API’sreduce() method and how it can be used to perform reduction operations on the streams of data.
 
 
 
 

1.1.1 What is ‘reducing’ in the context of Streams?

Reducing in the context of Java8 Streams refers to theprocess of combining all elements in the stream repeatedly to produce a single value which is returned as the result of the reduction operation. Given a stream of elements there could be various ways in which one can reduce (or combine) them to a single result value such as summation of all elements (for numeric types), finding the maximum element from among all the elements (based on the element’s comparison order), and similar operations for combining multiple elements into a single resultant value.

Theprimary requirement of any reduction operation’s logic is that it should use two operands for the operation which are:

• The collective value aggregated or derived from the elements encountered so far which will be of the same type as the type of elements in the stream
• The value which is encountered next to the unprocessed value in the stream

Due to thisinherent nature of reduction, operations requiring two operands both of which are of the same type as the type of elements in the stream being processed. Stream API’sreduce() method also uses aBinaryOperator function for defining the reduction operation logic. Let us now take a look at how the Stream API’sreduce() operation is defined and used.

Method Signature

T reduce(T identity, BinaryOperator<T> accumulator)

Where,

• Theidentity is the initial value of the typeT which will be used as the first value in the reduction operation
• Anaccumulator is an instance of aBinaryOperator function of the typeT

1.2 Stream’s collect() Method

Collectors play an important role in Java 8 streams processing. They ‘collect’ the processed elements of the stream into a final representation. Invoking thecollect() method on a Stream, with a Collector instance passed as a parameter ends that Stream’s processing and returns back the final result.Stream.collect() method is thus aterminal operation. In other words,Stream.collect() method is used to receive the elements from a stream and store them in a collection.

Thecollect() operation accumulates the elements in a stream into a container such as a collection. It performs mutable reduction operation in which the reduced (final) value is a mutable result container such as anArrayList. This method takes aCollector implementation that provides useful reduction operations. TheCollectors class is a common implementation in the ‘JDK 1.8’. The following example accumulates emails of the persons into a list collection.

List<String> listEmails = listPersons.stream().map(p -> p.getEmail()).collect(Collectors.toList()); System.out.println("List of Emails: " + listEmails);

Now, open up the Eclipse Ide and let’s see how to work with Java8 Collectors and Streams API.

2. Java8 Collect vs. Reduce Example

2.1 Tools Used

We are using Eclipse Oxygen, JDK 8 and Maven.

2.2 Project Structure

Firstly, let’s review the final project structure, in case you are confused about where you should create the corresponding files or folder later!

2.3 Project Creation

This section will demonstrate on how to create a Java-based Maven project with Eclipse. In Eclipse IDE, go toFile -> New -> Maven Project.

In the New Maven Project window, it will ask you to select project location. By default, ‘Use default workspace location’ will be selected. Select the ‘Create a simple project (skip archetype selection)’ checkbox and just click on next button to proceed.

It will ask you to ‘Enter the group and the artifact id for the project’. We will input the details as shown in the below image. The version number will be by default:0.0.1-SNAPSHOT.

Click on Finish and the creation of a maven project is completed. If you observe, it has downloaded the maven dependencies and apom.xml file will be created. It will have the following code:

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>Java8CollectReduce</groupId><artifactId>Java8CollectReduce</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging></project>

Developers can start adding the dependencies that they want. Let’s start building the application!

3. Application Building

Below are the steps involved in developing this application.

3.1 Java Class Creation

Let’s create the required Java files. Right-click on thesrc/main/java folder,New -> Package.

A new pop window will open where we will enter the package name as:com.jcg.java.

Once the package is created in the application, we will need to create the ‘Collect’ and ‘Reduce’ implementation classes to illustrate the implementation ofCollectors andStreams API in Java8. Right-click on the newly created package:New -> Class.

Want to be a Java 8 Ninja ?

Subscribe to our newsletter and download the Java 8 FeaturesUltimateGuideright now!

In order to get you up to speed with the major Java 8 release, we have compiled a kick-ass guide with all the new features and goodies! Besides studying them online you may download the eBook in PDF format!

Download NOW!

Thank you!

We will contact you soon.

A new pop window will open and enter the file name as:ReduceTest. The implementation class will be created inside the package:com.jcg.java.

Repeat the step (i.e. Fig. 7) and enter the filename as:CollectTest. The implementation class will be created inside the package:com.jcg.java.

3.1.1 Implementation of Reduce Class

Let’s move to the 1st example where the reduction operation sums up all elements of the stream and the 2nd example where reduction operation finds the employee with the maximum salary. Let’s see the simple code snippet that follows this implementation.

ReduceTest.java

package com.jcg.java;import java.util.Arrays;import java.util.List;import java.util.Optional;public class ReduceTest {static List<Employee> employeeList = Arrays.asList(new Employee("Tom", 45, 7000.00),new Employee("Harry", 25, 10000.00),new Employee("Ethan", 65, 8000.00),new Employee("Nancy", 22, 12000.00),new Employee("Deborah", 29, 9000.00));public static void main(String[] args) {/***** E.g. #1 - Total Salary Expenses *****/Double totalSalaryExpense = (Double) employeeList.stream().map(emp -> emp.getSalary()).reduce(0.00,(a,b) -> a+b);System.out.println("Total Salary Expense?= " + totalSalaryExpense + "\n");/***** E.g. #2 - Employee Details Having Maximum Salary *****/Optional<Employee> maxSalaryEmp = employeeList.stream().reduce((Employee a, Employee b) -> a.getSalary() < b.getSalary() ? b:a);if(maxSalaryEmp.isPresent()) {System.out.println("Employee with Max. Salary?= "+ maxSalaryEmp.get());}}}

3.1.2 Implementation of Collector Class

Let’s move to the example where theStream.collect() method is used to receive elements from a stream and store them in a collection. Let’s see the simple code snippet that follows this implementation.

CollectTest.java

package com.jcg.java;import java.util.ArrayList;import java.util.List;import java.util.stream.Collectors;public class CollectTest {public static void main(String[] args) {List<Employee> empList = new ArrayList<Employee>();empList.add(new Employee("Tom", 45, 7000.00));empList.add(new Employee("Harry", 25, 10500.00));empList.add(new Employee("Ethan", 65, 8000.00));empList.add(new Employee("Nancy", 22, 12000.00));empList.add(new Employee("Deborah", 29, 9000.00));/***** Find Employees Whose Salaries Are Above 10000 *****/List<Employee> filteredList = empList.stream().filter(emp->emp.getSalary() > 10000).collect(Collectors.toList());filteredList.forEach(System.out::println);}}

Do remember, developers will have to use the ‘JDK 1.8‘ dependency for implementing this example.

4. Run the Application

To run the application, right-click on theReduceTest or theCollectTest class,Run As -> Java Application. Developers can debug the example and see what happens after every step!

5. Project Demo

The application shows the following logs as output.

ConsumerTest.java

# Logs for 'ReduceTest' #=========================Total Salary Expense?= 46000.0Employee with Max. Salary?= Employee Name: Nancy| Age: 22| Salary: 12000.0# Logs for 'CollectTest' #==========================Employee Name: Harry| Age: 25| Salary: 10500.0Employee Name: Nancy| Age: 22| Salary: 12000.0

That’s all for this post. Happy Learning!

6. Conclusion

In this tutorial, we looked at what are thecollect() andreduce() methods defined in Java8. I hope this article served developers whatever they were looking for.

7. Download the Eclipse Project

This was an example ofcollect() andreduce() methods in Java8.

Do you want to know how to develop your skillset to become aJava Rockstar?

Subscribe to our newsletter to start Rockingright now!

To get you started we give you our best selling eBooks forFREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to theTerms andPrivacy Policy

Sign up

Thank you!

We will contact you soon.