Stream.reduce and summing numbers

For this lesson, we'll focus on the reduction rules interviewers expect for Java 21: the three reduce overloads, true identity values, associativity, parallel combiner behavior, when collect is the better tool, and the practical ways to sum numbers. We cover primitive stream mechanics in Primitive streams: IntStream, LongStream and DoubleStream, so here we'll link there instead of repeating the whole boxing story.

01Picture it first: receipts into one till

Picture four cashiers each adding a stack of receipts. If the store is sequential, one cashier starts at zero and adds every receipt. If the store is parallel, several cashiers each start with the identity, add their stack, and then a manager combines the subtotals.

That picture exposes the trap. The identity is used per partial reduction, not only once in the whole program. If it is not truly neutral, parallel reduction changes the answer.

Fig. 1

A sequential reduce uses one identity and one accumulator path, while a parallel reduce uses an identity per partition and combines the partial totals

Notice that the combiner is not decoration. In parallel reduction, it is how partial answers become the final answer. In sequential execution, you may not notice a bad combiner for a long time.

02reduce under the hood: the three overloads

The simplest overload gives an identity and an accumulator. Use it when the result type is the same as the stream element type and there is a natural value for an empty stream.

import java.util.List;

final class ReduceWithIdentityDemo {
    public static void main(String[] args) {
        List<Integer> cents = List.of(1200, 800, 500);

        int total = cents.stream()
                .reduce(0, Integer::sum);

        int product = List.of(2, 3, 4).stream()
                .reduce(1, (a, b) -> a * b);

        String joined = List.of("A", "B", "C").stream()
                .reduce("", (left, right) -> left + right);

        System.out.println(total);   // 2500
        System.out.println(product); // 24
        System.out.println(joined);  // ABC
    }
}

Notice three things:

• The identity for addition is 0 because 0 + x == x.
• The identity for multiplication is 1 because 1 * x == x.
• The empty string is an identity for concatenation, but repeated string concatenation in a stream is usually not the best performance choice.

The accumulator-only overload returns Optional<T> because an empty stream has no first value to start from.

import java.util.List;
import java.util.Optional;

final class ReduceOptionalDemo {
    public static void main(String[] args) {
        Optional<Integer> max = List.of(7, 3, 9).stream()
                .reduce(Integer::max);

        Optional<Integer> emptyMax = List.<Integer>of().stream()
                .reduce(Integer::max);

        System.out.println(max.orElseThrow()); // 9
        System.out.println(emptyMax.isEmpty()); // true
    }
}

This is the overload I use for max, min or "there may be no answer" cases. It avoids inventing a fake identity like Integer.MIN_VALUE when that value could be real data.

The three-argument overload is the one many candidates memorize but do not understand. It exists for a result type U that may differ from element type T, and for parallel execution where partial U results must be combined.

import java.util.List;

record Invoice(String id, int cents) { }

final class ReduceThreeArgDemo {
    public static void main(String[] args) {
        List<Invoice> invoices = List.of(
                new Invoice("i-1", 1200),
                new Invoice("i-2", 800),
                new Invoice("i-3", 500)
        );

        int total = invoices.stream()
                .reduce(
                        0,
                        (subtotal, invoice) -> subtotal + invoice.cents(),
                        Integer::sum);

        System.out.println(total); // 2500
    }
}

Here the stream element is Invoice, but the result is Integer. The accumulator turns (Integer, Invoice) into a new Integer. The combiner turns (Integer, Integer) partial totals into one total.

03Identity and associativity: where parallel bugs come from

The identity must be neutral for the operation, and the operation must be associative. Associative means regrouping does not change the answer: (a + b) + c equals a + (b + c). Addition of integers is associative in mathematical intent, though Java integer overflow still wraps; subtraction is not associative.