Find the product of all employee ages using reduce()

• Identity for multiplication: 1, because 1 * x == x and the empty product is 1.
• mapToLong gives a LongStream for more headroom before overflow.
• Silent overflow: long multiplication wraps around with no exception.
• Math.multiplyExact: throws ArithmeticException on overflow instead of wrapping.
• BigInteger: has no fixed range and cannot overflow at all.

How do you multiply all ages with reduce?

package com.bank.hr;

import java.util.List;

public class ProductOfAges {
    public static void main(String[] args) {
        List<Employee> staff = List.of(
            new Employee("Rajesh",  35),
            new Employee("Priya",   30),
            new Employee("Amit",    28),
            new Employee("Kavita",  32));

        long product = staff.stream()
            .mapToLong(Employee::getAge)
            .reduce(1L, (a, b) -> a * b);

        System.out.println("Product of ages: " + product);
    }
}

Product of ages: 940800

Why is the identity 1 and not 0?

| Identity | Effect | Correct? |
|---|---|---|
| 1 | 1 * 35 * 30 * 28 * 32 = 940800 | Yes |
| 0 | 0 * 35 * 30 * 28 * 32 = 0 | No! |

The identity must satisfy identity * x == x. For multiplication that is 1. Using 0 would make every product zero.

How do you guard against overflow?

// WRONG: silent overflow wraps to a wrong number
long product = staff.stream()
    .mapToLong(Employee::getAge)
    .reduce(1L, (a, b) -> a * b);
// If product exceeds Long.MAX_VALUE, wraps silently!

// CORRECT: Math.multiplyExact throws on overflow
long safeProduct = staff.stream()
    .mapToLong(Employee::getAge)
    .reduce(1L, Math::multiplyExact);
// Throws ArithmeticException if overflow occurs

What about BigInteger for large products?

import java.math.BigInteger;

BigInteger product = staff.stream()
    .reduce(
        BigInteger.ONE,
        (acc, e) -> acc.multiply(BigInteger.valueOf(e.getAge())),
        BigInteger::multiply);

System.out.println("BigInteger product: " + product);

BigInteger product: 940800

BigInteger has no fixed range and cannot overflow.

What are common mistakes?

Mistake: using 0 as the identity for multiplication.

// WRONG: 0 collapses the entire product to 0
long wrong = staff.stream()
    .mapToLong(Employee::getAge)
    .reduce(0L, (a, b) -> a * b);
// Always 0!

// CORRECT: identity for multiplication is 1
long correct = staff.stream()
    .mapToLong(Employee::getAge)
    .reduce(1L, (a, b) -> a * b);

What about an empty stream?

With identity 1L, an empty stream returns 1L, which is the mathematical convention for the empty product.

Why does this return a plain long and not Optional?

The identity form of reduce always has a value (the identity for empty streams), so it returns a plain long, not an OptionalLong. The no-identity form would return OptionalLong.

What should a senior engineer know?

• Multiplying many values grows exponentially; even a long can overflow for a moderate number of employees.
• In financial models, use Math.multiplyExact to turn silent overflow into a loud exception.
• For truly large products, use BigInteger.
• The accumulator must be associative for parallel correctness.

What are common interview follow-up questions?

• "Why not use 0 as the identity?" It collapses the entire product to 0.
• "How do you detect overflow?" Use Math.multiplyExact which throws ArithmeticException.
• "What happens with an empty stream?" Returns the identity (1).