How Do map, filter, and reduce Compose?

They are the three classic stages of a data pipeline, and each one has a single job.

filter keeps the elements that match a Predicate and drops the rest. It preserves the element type and the count changes. map transforms each element with a Function and keeps the count the same, unless the function returns a stream — in which case it is flatMap, which flattens one level. reduce folds the whole stream down into a single value using a BinaryOperator, and it is the only one of the three that collapses the stream.

The composition rule is simple: each stage takes a stream and returns a stream, until a terminal operation ends the chain. So filter then map means filter first, then transform the survivors. Reversing them changes the meaning — mapping first might transform every element and then throw away most of the results, which is wasted work.

That ordering rule is where a real performance difference shows up. If the filter is cheap and the map is expensive, filter first. If the map is cheap and the filter is expensive, map first. And because the stream is lazy and can short-circuit, putting a limit after a filter stops the source being read at all once enough elements have passed.

One thing worth saying: reduce and collect are alternatives for producing a result. Reduce folds with a binary operation; collect applies a collector, which can be much more expressive — grouping, joining, summarising. When you want a single value, reduce is the natural choice; when you want a collection or a summary, use collect.

There are three ways, and they suit different situations. The map plus reduce form is the general one. The mapToInt plus sum form avoids boxing entirely and is the fastest for numbers. And collect with the summing collector produces the same answer in a different shape.

There are three ways, and they suit different situations. The map plus reduce form is the general one and works for any element type. The mapToInt plus sum form avoids boxing entirely and is the fastest for numbers, because a stream of Integer allocates a wrapper for every element on its way through the pipeline. And collect with a summarising collector produces the same answer in a different shape.

When to use which. Use reduce when you are folding the stream into a single value that is not a collection — a sum, a maximum, a concatenation, a custom aggregate. Use collect when you want a collection, a map, or one of the summarising collectors such as averagingInt, counting or joining. The deciding factor is the shape of the result, not performance.

Two performance notes. The identity value in the two-argument reduce matters: it is returned when the stream is empty, so reduce with a zero identity gives zero for an empty stream while the single-argument version returns an empty Optional. And mapToInt exists specifically so that a stream of Integer does not allocate a boxed object per element.

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> lines = List.of("apple", "fig", "banana");

        // map + reduce to sum.
        int total = lines.stream()
                .map(String::length)
                .reduce(0, Integer::sum);
        System.out.println("total length : " + total);

        // The same thing with sum(), with no boxing.
        int viaSum = lines.stream().mapToInt(String::length).sum();
        System.out.println("via sum      : " + viaSum);

        // reduce without an identity returns an Optional.
        Optional<String> longest = lines.stream()
                .reduce((a, b) -> a.length() >= b.length() ? a : b);
        System.out.println("longest      : " + longest.orElse("none"));

        // collect with a joining collector.
        System.out.println("joined       : "
                + lines.stream().collect(Collectors.joining(", ")));
    }
}

The output shows all four results. Both summing forms produce 14, the reduce without an identity picks the longest word, and the joining collector produces a single comma-separated string.

When to use which. Use reduce when you are folding the stream into one value that is not a collection — a sum, a maximum, a concatenation, a custom aggregate. Use collect when you want a collection, a map, or one of the summarising collectors such as averagingInt, counting or joining. The deciding factor is the shape of the result, not performance.

Two performance notes. The identity value in reduce(identity, accumulator) matters: it is returned when the stream is empty, so reduce(0, Integer::sum) gives 0 for an empty stream while the two-argument version returns an empty Optional. And mapToInt exists specifically so that a stream of Integer does not allocate a boxed object per element — with map alone, every element becomes a boxed Integer on its way through the pipeline.

Reduce folds every element of the stream into one result using a binary operation. There are two forms, and the difference is what happens with an empty stream.

The form with an identity — reduce(identity, accumulator) — always returns a value. The identity is returned unchanged if the stream is empty, and it must be an identity for the operation: combining it with any element must produce that element unchanged. So reduce(0, Integer::sum) gives 0 for an empty stream, and reduce("", (a, b) -> a + b) gives an empty string.

The form without an identity returns an Optional, because an empty stream has nothing to fold. This is the right form when an empty input is genuinely an error or a special case, and you want the caller to deal with it.

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4);

        // reduce with an identity value.
        int sum = numbers.stream().reduce(0, Integer::sum);
        System.out.println("sum     : " + sum);

        // reduce without an identity returns an Optional.
        Optional<Integer> product = numbers.stream().reduce((a, b) -> a * b);
        System.out.println("product : " + product.orElse(0));

        // Strings concatenate naturally.
        String joined = List.of("a", "b", "c").stream()
                .reduce("", (a, b) -> a + b);
        System.out.println("joined  : " + joined);

        // The empty case behaves differently in the two forms.
        System.out.println("empty with identity : "
                + List.<Integer>of().stream().reduce(0, Integer::sum));
        System.out.println("empty without       : "
                + List.<Integer>of().stream().reduce((a, b) -> a * b).isPresent());
    }
}

The output shows the two forms behaving exactly as described. The sum is 10, the product is 24, the join produces abc, and the empty stream gives 0 with an identity but an absent Optional without one.

One thing to watch: reduce is not associative-safe in the sense that the operation must be associative for a parallel stream to produce the correct answer. Integer addition and multiplication are associative, so they are fine. Subtraction is not — (a - b) - c differs from a - (b - c) — so a parallel reduce with subtraction can give a different answer depending on how the work was split. If you use reduce in a parallel stream, check that your operation is associative.