Streams: filter, map and collect

Why streams?

Many loops follow the same shape: go through items, keep some, transform them, combine the result. The Stream API (Java 8) lets you write that as a pipeline of named steps. The code reads like the requirement: "paid orders from Pune, their amounts, total".

record Order(String id, String city, double amount, boolean paid) {}
List<Order> orders = List.of(
    new Order("O1", "Pune", 450, true),
    new Order("O2", "Delhi", 1200, false),
    new Order("O3", "Pune", 900, true),
    new Order("O4", "Goa", 300, true));

// Loop version
double total = 0;
for (Order o : orders) if (o.paid() && o.city().equals("Pune")) total += o.amount();

// Stream version
double total2 = orders.stream()
        .filter(Order::paid)
        .filter(o -> o.city().equals("Pune"))
        .mapToDouble(Order::amount)
        .sum();                                  // 1350.0

The three parts of a pipeline

1. Source: list.stream(), Arrays.stream(array), Stream.of(a, b, c), IntStream.rangeClosed(1, 10), Files.lines(path).
2. Intermediate operations (return a new stream, run lazily): filter, map, mapToInt/mapToDouble, flatMap, sorted, distinct, limit, skip, peek.
3. One terminal operation (produces a result and runs the pipeline): toList, collect, count, sum, average, min, max, reduce, anyMatch, allMatch, findFirst, forEach.

List<String> topCities = orders.stream()
        .filter(Order::paid)
        .sorted(Comparator.comparingDouble(Order::amount).reversed())
        .map(Order::city)
        .distinct()
        .limit(2)
        .toList();                       // [Pune, Goa]  (toList: Java 16+, unmodifiable)

long unpaid = orders.stream().filter(o -> !o.paid()).count();             // 1
boolean anyBig = orders.stream().anyMatch(o -> o.amount() > 1000);        // true
OptionalDouble avg = orders.stream().mapToDouble(Order::amount).average(); // OptionalDouble[712.5]
int sumOfSquares = IntStream.rangeClosed(1, 5).map(n -> n * n).sum();     // 55
double product = Stream.of(2.0, 3.0, 4.0).reduce(1.0, (a, b) -> a * b);  // 24.0

Lazy and single-use

Intermediate operations do nothing until a terminal operation is called; then each element flows through the whole pipeline. That allows short-circuiting: findFirst or limit stop as soon as they have enough. A stream can be consumed only once; calling a second terminal operation on the same stream throws IllegalStateException: stream has already been operated upon or closed.

Primitive streams

Stream<Integer> boxes every number. IntStream, LongStream and DoubleStream work on primitives and add sum, average, min, max and summaryStatistics. Switch with mapToInt/mapToDouble and back with boxed().