Java Stream forEach vs map — When to Use Each and Why

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

public class OrderPriceTransformer {

    record Order(String productName, double priceUsd) {}

    public static void main(String[] args) {

        List<Order> orders = List.of(
            new Order("Wireless Keyboard", 49.99),
            new Order("USB-C Hub",         29.99),
            new Order("Mechanical Mouse",  79.99)
        );

        double conversionRate = 1.08; // USD to EUR (example rate)

        // map() transforms each Order into a formatted price string.
        // Nothing runs here yet — this is just a description of what to do.
        List<String> eurPriceLabels = orders.stream()
            .map(order -> order.priceUsd() * conversionRate)   // Step 1: convert price to EUR
            .map(eurPrice -> String.format("EUR %.2f", eurPrice)) // Step 2: format as string
            .collect(Collectors.toList()); // Terminal op — THIS is when both maps actually run

        // Now we print the results
        eurPriceLabels.forEach(System.out::println);
    }
}

import java.util.List;
import java.util.ArrayList;

public class NotificationDispatcher {

    record User(String name, String email, boolean hasOptedIntoEmails) {}

    // Simulates sending an email — in real code this might call an SMTP client
    static void sendWelcomeEmail(User user) {
        System.out.println("Sending welcome email to: " + user.email());
    }

    public static void main(String[] args) {

        List<User> newSignups = List.of(
            new User("Alice",   "alice@example.com",  true),
            new User("Bob",     "bob@example.com",    false),
            new User("Charlie", "charlie@example.com", true)
        );

        // We filter to opted-in users, then use forEach to trigger
        // the side effect (sending email). We don't need a return value.
        newSignups.stream()
            .filter(User::hasOptedIntoEmails)     // Keep only opted-in users
            .forEach(NotificationDispatcher::sendWelcomeEmail); // Side effect — no return value needed

        // forEach has consumed the stream. You cannot chain more stream ops after this.
        // If you tried .filter(...) after forEach, it would not compile.

        System.out.println("--- Dispatch complete ---");
    }
}

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

public class ProductCatalogPipeline {

    // Raw data as it might come from a database or API
    record RawProduct(String sku, String rawName, int stockCount, double wholesalePrice) {}

    // Clean domain model for our application
    record CatalogEntry(String sku, String displayName, double retailPrice, boolean inStock) {}

    public static void main(String[] args) {

        List<RawProduct> rawInventory = List.of(
            new RawProduct("KB-001", "wireless keyboard",  120, 22.50),
            new RawProduct("MS-002", "mechanical mouse",     0, 35.00),
            new RawProduct("HB-003", "usb-c hub 7-port",    45, 14.00),
            new RawProduct("WC-004", "1080p webcam",          3, 28.00)
        );

        double markupMultiplier = 2.2; // Retail price = wholesale * 2.2

        // TRANSFORMATION PHASE: use map() to convert raw data into clean domain objects
        List<CatalogEntry> liveCatalog = rawInventory.stream()
            .map(raw -> new CatalogEntry(
                raw.sku(),
                toTitleCase(raw.rawName()),           // Clean up display name
                Math.round(raw.wholesalePrice() * markupMultiplier * 100.0) / 100.0, // Retail price
                raw.stockCount() > 0                 // In stock if count > 0
            ))
            .filter(CatalogEntry::inStock)            // Only show in-stock items to customers
            .collect(Collectors.toList());            // Materialise the stream into a list

        // ACTION PHASE: use forEach() only when we're done transforming
        // Here we simulate rendering each entry to a storefront
        System.out.println("=== Live Product Catalog ===");
        liveCatalog.forEach(entry ->
            System.out.printf("[%s] %s — $%.2f %s%n",
                entry.sku(),
                entry.displayName(),
                entry.retailPrice(),
                entry.inStock() ? "(In Stock)" : "(Out of Stock)"
            )
        );
    }

    // Simple helper — capitalises first letter of each word
    static String toTitleCase(String input) {
        String[] words = input.split(" ");
        StringBuilder result = new StringBuilder();
        for (String word : words) {
            if (!word.isEmpty()) {
                result.append(Character.toUpperCase(word.charAt(0)))
                      .append(word.substring(1))
                      .append(" ");
            }
        }
        return result.toString().trim();
    }
}