The Java Stream API

import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // ── Three ways to CREATE a stream ──────────────────────────────
        List<String> names = List.of("Alice", "Bob", "Charlie", "Bob");

        // 1) From a collection: .stream()
        names.stream().forEach(n -> System.out.println("From list: " + n));

        // 2) From values: Stream.of(...)
        Stream.of("red", "green", "blue")
              .forEach(c -> System.out.println("Stream.of: " + c));

        // 3) From a range of ints: IntStream.range(start, end)  (end is EXCLUSIVE)
        IntStream.range(1, 4)               // 1, 2, 3  (NOT 4)
                 .forEach(i -> System.out.println("range: " + i));

        // ── INTERMEDIATE ops build a recipe (lazy, nothing runs yet) ───
        // ── The TERMINAL op (collect) runs the whole pipeline ──────────
        List<String> result = names.stream()
            .filter(n -> n.length() > 3)    // keep names longer than 3 chars ("Bob" is out)
            .distinct()                     // drop any duplicate values
            .map(String::toUpperCase)       // transform each surviving element
            .sorted()                       // order alphabetically
            .toList();                      // TERMINAL: collect into a List (Java 16+)

        System.out.println("Pipeline result: " + result);
    }
}

From list: Alice
From list: Bob
From list: Charlie
From list: Bob
Stream.of: red
Stream.of: green
Stream.of: blue
range: 1
range: 2
range: 3
Pipeline result: [ALICE, CHARLIE]

import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class Main {
    record Product(String name, String category, double price) {}

    public static void main(String[] args) {
        List<Product> products = List.of(
            new Product("Apple",  "Fruit",  0.50),
            new Product("Banana", "Fruit",  0.30),
            new Product("Carrot", "Veg",    0.20),
            new Product("Milk",   "Dairy",  1.20),
            new Product("Cheese", "Dairy",  3.50));

        // count() — how many items survive the filter?
        long cheapCount = products.stream()
            .filter(p -> p.price() < 1.00)
            .count();
        System.out.println("Items under $1: " + cheapCount);

        // reduce() — fold every price into one running total
        double total = products.stream()
            .map(Product::price)
            .reduce(0.0, Double::sum);          // start at 0.0, keep adding
        System.out.printf("Total price: $%.2f%n", total);

        // Collectors.toList() — gather names into a List
        List<String> nameList = products.stream()
            .map(Product::name)
            .collect(Collectors.toList());
        System.out.println("Names: " + nameList);

        // Collectors.joining() — concatenate with a delimiter
        String joined = products.stream()
            .map(Product::name)
            .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("Joined: " + joined);

        // Collectors.toMap() — build a name -> price lookup
        Map<String, Double> priceOf = products.stream()
            .collect(Collectors.toMap(Product::name, Product::price));
        System.out.println("Milk costs: $" + priceOf.get("Milk"));

        // Collectors.groupingBy() — like SQL GROUP BY
        Map<String, List<String>> byCategory = products.stream()
            .collect(Collectors.groupingBy(Product::category,
                     Collectors.mapping(Product::name, Collectors.toList())));
        new TreeMap<>(byCategory).forEach((cat, items) ->
            System.out.println(cat + ": " + String.join(", ", items)));
    }
}

Items under $1: 3
Total price: $5.70
Names: [Apple, Banana, Carrot, Milk, Cheese]
Joined: [Apple, Banana, Carrot, Milk, Cheese]
Milk costs: $1.2
Dairy: Milk, Cheese
Fruit: Apple, Banana
Veg: Carrot

import java.util.List;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        // ── LAZY EVALUATION proof ──────────────────────────────────────
        // map() prints a tag as each element passes. Because limit(2) is a
        // short-circuiting terminal-feeder, the pipeline stops after 2 — it
        // does NOT process all five. Nothing runs until findFirst() pulls.
        System.out.println("Lazy demo:");
        java.util.Optional<Integer> first = List.of(1, 2, 3, 4, 5).stream()
            .map(n -> {
                System.out.println("  mapping " + n);
                return n * 10;
            })
            .filter(n -> n > 15)
            .findFirst();                   // pulls only until the first match
        System.out.println("First match: " + first.get());

        // ── PARALLEL stream ────────────────────────────────────────────
        // Splits work across CPU cores via the ForkJoinPool. Only worth it
        // for LARGE datasets and CPU-heavy, stateless work. The RESULT of a
        // reduction is deterministic; the processing ORDER is not.
        long sum = IntStream.rangeClosed(1, 1_000_000)
            .parallel()                     // opt in to parallelism
            .filter(n -> n % 2 == 0)        // even numbers only
            .mapToLong(n -> (long) n)
            .sum();                         // associative reduction — safe in parallel
        System.out.println("Sum of evens 1..1,000,000: " + sum);
    }
}

Lazy demo:
  mapping 1
  mapping 2
First match: 20
Sum of evens 1..1,000,000: 250000500000