Reduce Java

In Java, reducing is a terminal operation that aggregates a stream into a type or a primitive type. Java 8 provides Stream API contains set of predefined reduction operations such as average(), sum(), min(), max(), and count(). These operations return a value by combining the elements of a stream. In Java, reduce() is a method of the Stream interface. In this section, we will discuss the Java Stream.reduce() method in detail.

It is the method of combining all elements. For each element presented in the stream, the reduce() method applies the binary operator. In that stream, the first argument to the operator must return the value of the previous application and the second argument must return the current stream element.

It allows us to produce a single result from a sequence of elements by repeatedly applying a combining operation to the elements in the sequence called reducing.

There are the following three variants of Stream.reduce() methods:

1. reduce(BinaryOperator<T> accumulator)

It performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.

2. reduce(Tidentity, BinaryOperator<T> accumulator)

Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.

3. reduce(U identity, BiFunction<U,?super T,U> accumulator, BinaryOperator<U> combiner)

Performs a reduction on the elements of this stream, using the provided identity, accumulation, and combining functions.

In the above methods, three elements are used as parameter:

T: type of the data.
identity: It defines the initial value of reduction operation.
accumulator: It is a function to combine two values i.e. partial result of the reduction operation and the next element of the stream.
combiner: It combines the partial result of the reduction operation.

Let's take some examples of operations to understand the reduce() method of the Stream class.

Java Stream.reduce() Example

ReduceExample1.java

//import classes and packages for implementing the ReduceExample1 class
import java.util.*; 
//create class ReduceExample1  
class ReduceExample1 { 
    // main() method starts
    public static void main(String[] args) 
    { 
        // create a list of names to perform operations 
        List<String> javaTpointStudents = Arrays.asList("Emma Watson", "Paul Walker", "Leesa", 
                                           "James", "Lilly"); 
        // The reduce() method takes the lambda expression that take two string type values and returns a longer string
		//The Optional data is returned as a result from the reduce() method because the list can be emplty on which reduce() method is called.
        Optional<String> newString = javaTpointStudents.stream().reduce((firstName, secondName)-> firstName.length() > secondName.length()? firstName : secondName); 
        // show the result returned by the reduce method
        newString.ifPresent(System.out::println); 
    } 
}

Output:

ReduceExample2.java

//import classes and packages for implementing the ReduceExample2 class
import java.util.*; 
//create class ReduceExample2 
class ReduceExample2 { 
    // main() method starts
    public static void main(String[] args) 
    { 
        // create a array of monuments to perform operations 
        String[] monuments = { "Taj Mahal", "Qutab Minar", "Konark Sun Temple", "India Gate", "Charminar" }; 
		// The reduce() method takes the lambda expression that take two string type values and returns a longer string
		//The Optional data is returned as a result from the reduce() method because the list can be emplty on which reduce() method is called.
		
        Optional<String> newCombineMonument = Arrays.stream(monuments).reduce((firstMonument, secondMonument)-> firstMonument + "-" + secondMonument); 
  
        // show the result returned by the reduce method
        if (newCombineMonument.isPresent()) { 
            System.out.println(newCombineMonument.get()); 
        } 
    } 
}

Output:

ReduceExample3.java

//import classes and packages for implementing the ReduceExample2 class
import java.util.*; 
//create class ReduceExample3
class ReduceExample3 { 
    // main() method starts 
    public static void main(String[] args) 
    { 
        // Create a list of numbers either positve or negative
        List<Integer> numbers = Arrays.asList(8, -4, 16, 0, 1, -6, 3); 
        // calculate sum of all the elements of the numbers array using the reduce method 
        float sumOfElements = numbers.stream().reduce(0, (firstElement, secondElement) -> firstElement + secondElement); 
        // show the result returned by the reduce method
        System.out.println("The sum of all elements of numbers array " + sumOfElements); 
    } 
}

Output:

ReduceExample4.java

//import classes and packages for implementing the ReduceExample4 class
import java.util.*; 
import java.util.stream.IntStream; 
//create class ReduceExample4
class ReduceExample4 { 
    // main() method starts 
    public static void main(String[] args) 
    { 
        // calculate the product of elements that comes in given range excluding the rightmost element 
        int productOfElements = IntStream.range(5, 12).reduce((firstNumber, secondNumber) -> firstNumber * secondNumber).orElse(-1); 
        // show the result returned by the reduce method
        System.out.println("The product of all the elements come in given range is: " + productOfElements); 
    } 
}

Output:

ReduceExample5.java

//import classes and packages for implementing the ReduceExample5 class
import java.math.BigDecimal;
import java.util.Arrays;
import java.math.RoundingMode;
import java.util.List;
//create class ReduceExample5
public class ReduceExample5{
	//main() method starts
    public static void main(String[] args) {
		//create list of invoices by using wrapper class
        List<Invoice> listOfInvoices = Arrays.asList(
                new Invoice("productA31", BigDecimal.valueOf(131), BigDecimal.valueOf(5)),
				new Invoice("productA32", BigDecimal.valueOf(121), BigDecimal.valueOf(3)),
                new Invoice("productA33", BigDecimal.valueOf(99), BigDecimal.valueOf(1.5))
                
        );
		//calculate price of the product 
        BigDecimal sum = listOfInvoices.stream().map(data -> data.getQTY().multiply(data.getPrice())).reduce(BigDecimal.ZERO, BigDecimal::add);
		
		// show the result returned by the reduce method
		System.out.println(sum);
    }
}
//create wrapper class
class Invoice {
    String invoiceNo;
    BigDecimal price;
    BigDecimal qty;
   public Invoice (String invoiceNo, BigDecimal price, BigDecimal qty){
	   this.invoiceNo = invoiceNo;
	   this.price = price;
	   this.qty = qty;
   }
	public BigDecimal getPrice(){
		return price;
	}
	public BigDecimal getQTY(){
		return qty;
	}
}

Output: