forEach vs Map in Java Streams: Terminal vs Intermediate Operations

package io.thecodeforge.java.streams;

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

/**
 * Production-grade example of map() for functional transformation.
 * map() is non-interfering and stateless.
 */
public class MapDemo {
    public static void main(String[] args) {
        List<String> names = List.of("alice", "bob", "charlie", "diana");

        // map: String → String (uppercase transformation)
        List<String> upper = names.stream()
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());
        System.out.println(upper);  // [ALICE, BOB, CHARLIE, DIANA]

        // map: String → Integer (type transformation)
        List<Integer> lengths = names.stream()
                                     .map(String::length)
                                     .collect(Collectors.toList());
        System.out.println(lengths);  // [5, 3, 7, 5]

        // Chaining: Clean pipeline following LeetCode optimization standards
        List<String> longNames = names.stream()
                                      .filter(n -> n.length() > 4)
                                      .map(String::toUpperCase)
                                      .collect(Collectors.toList());
        System.out.println(longNames);  // [ALICE, CHARLIE, DIANA]
    }
}

package io.thecodeforge.java.streams;

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

/**
 * Demonstrates the terminal nature of forEach and common pitfalls.
 */
public class ForEachDemo {
    public static void main(String[] args) {
        List<String> items = List.of("apple", "banana", "cherry");

        // forEach: consume each element — returns void. Ideal for logging/IO.
        items.stream().forEach(item -> System.out.println("Processing: " + item));

        // Equivalent — and simpler — without stream (prefer this for simple iteration):
        items.forEach(System.out::println);

        // ANTI-PATTERN: Mutating external state inside forEach.
        // This is not thread-safe and breaks the functional paradigm.
        List<String> bad = new ArrayList<>();
        items.stream().forEach(s -> bad.add(s.toUpperCase())); 
        System.out.println("Side-effect result: " + bad);

        // PRODUCTION PATTERN: Use map + collect (Thread-safe, parallel-ready)
        List<String> good = items.stream()
                                 .map(String::toUpperCase)
                                 .collect(Collectors.toList());
        System.out.println("Functional result: " + good);
    }
}

package io.thecodeforge.java.streams;

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

public class FlatMapDemo {
    public static void main(String[] args) {
        List<List<Integer>> nested = List.of(
            List.of(1, 2, 3),
            List.of(4, 5),
            List.of(6, 7, 8, 9)
        );

        // flatMap flattens Stream<List<Integer>> to Stream<Integer>
        List<Integer> flat = nested.stream()
                                   .flatMap(List::stream)
                                   .collect(Collectors.toList());
        System.out.println(flat);  // [1, 2, 3, 4, 5, 6, 7, 8, 9]

        // Real use case: Extracting unique words from sentences
        List<String> sentences = List.of("hello world", "java streams forge");
        List<String> uniqueWords = sentences.stream()
                                            .flatMap(s -> Arrays.stream(s.split(" ")))
                                            .distinct()
                                            .collect(Collectors.toList());
        System.out.println(uniqueWords);  // [hello, world, java, streams, forge]
    }
}