Java LongStream reduce() Method

The reduce() method in Java, part of the java.util.stream.LongStream interface, is used to perform a reduction on the elements of the stream, using an associative accumulation function and returning an OptionalLong. This method is useful when you need to combine the elements of the stream into a single result, such as summing the elements or finding the product.

Table of Contents

1. Introduction
2. reduce() Method Syntax
3. Understanding reduce()
4. Examples
   • Basic Usage
   • Using reduce() with an Identity Value
   • Using reduce() with an Identity Value and Combiner
5. Real-World Use Case
6. Conclusion

Introduction

The reduce() method performs a reduction on the elements of the stream using an associative accumulation function. It can be used to aggregate elements into a single result, such as calculating the sum, product, or finding the maximum or minimum value.

reduce() Method Syntax

1. With Accumulator

OptionalLong reduce(LongBinaryOperator accumulator)

2. With Identity and Accumulator

long reduce(long identity, LongBinaryOperator accumulator)

3. With Identity, Accumulator, and Combiner

<U> U reduce(U identity, BiFunction<U, ? super Long, U> accumulator, BinaryOperator<U> combiner)

Parameters:

• accumulator: A LongBinaryOperator that combines two values and produces a new value.
• identity: The initial value for the reduction operation and the default result if the stream is empty.
• combiner: A BinaryOperator that combines two accumulated results. This is typically used in parallel streams.

Returns:

• An OptionalLong describing the result of the reduction with the first syntax, or a long value with the second syntax. The third syntax returns a result of type U.

Throws:

• This method does not throw any exceptions.

Understanding reduce()

The reduce() method processes the elements of the stream to combine them into a single result. Depending on the syntax used, it can return an OptionalLong, a long value, or a result of type U. The operation is associative, meaning the order of operations does not affect the final result.

Examples

Basic Usage

To demonstrate the basic usage of reduce(), we will create a LongStream and use reduce() to sum the elements.

Example

import java.util.OptionalLong;
import java.util.stream.LongStream;

public class ReduceExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(1L, 2L, 3L, 4L, 5L);

        // Use reduce() to sum the elements
        OptionalLong sum = stream.reduce(Long::sum);

        // Print the sum if present
        sum.ifPresent(System.out::println);
    }
}

Output:

15

Using reduce() with an Identity Value

This example shows how to use reduce() with an identity value to find the product of the elements.

Example

import java.util.stream.LongStream;

public class ReduceWithIdentityExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(1L, 2L, 3L, 4L, 5L);

        // Use reduce() with an identity value to find the product of the elements
        long product = stream.reduce(1L, (a, b) -> a * b);

        // Print the product
        System.out.println(product);
    }
}

Output:

120

Using reduce() with an Identity Value and Combiner

This example shows how to use reduce() with an identity value, an accumulator, and a combiner. It is particularly useful in parallel streams.

Example

import java.util.ArrayList;
import java.util.List;
import java.util.stream.LongStream;

public class ReduceWithCombinerExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(1L, 2L, 3L, 4L, 5L);

        // Use reduce() with an identity value, an accumulator, and a combiner to collect elements in a list
        List<Long> result = stream.reduce(
            new ArrayList<Long>(),
            (list, element) -> {
                list.add(element);
                return list;
            },
            (list1, list2) -> {
                list1.addAll(list2);
                return list1;
            }
        );

        // Print the result list
        result.forEach(System.out::println);
    }
}

Output:

Compilation failed.

Real-World Use Case

Calculating the Total Revenue

In real-world applications, the reduce() method can be used to calculate the total revenue from a stream of transaction amounts.

Example

import java.util.stream.LongStream;

public class ReduceTotalRevenueExample {
    public static void main(String[] args) {
        LongStream transactionAmounts = LongStream.of(1000L, 2000L, 1500L, 3000L, 2500L);

        // Use reduce() to calculate the total revenue
        long totalRevenue = transactionAmounts.reduce(0L, Long::sum);

        // Print the total revenue
        System.out.println("Total Revenue: " + totalRevenue);
    }
}

Output:

Total Revenue: 10000

Conclusion

The LongStream.reduce() method is used to perform a reduction on the elements of the stream, using an associative accumulation function and returning an OptionalLong. This method is particularly useful for combining elements of the stream into a single result, such as calculating the sum, product, or other aggregated values. By understanding and using this method, you can efficiently manage and process streams of values in your Java applications, ensuring that elements are reduced as needed.