StreamPipelineDemo.java

import java.util.*;
import java.util.stream.*;

/**
 * Demonstrates declarative Stream Pipelines in modern Java
 * Key concepts: Functional programming, lazy evaluation, terminal operations
 */
public class StreamPipelineDemo {

    public static void main(String[] args) {
        System.out.println("=== Stream Pipeline Demo ===\n");

        demonstrateBasicOperations();
        demonstrateComplexPipeline();
        demonstrateLazyEvaluation();
        demonstrateCollectors();
    }

    private static void demonstrateBasicOperations() {
        System.out.println("1. Basic Stream Operations");

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Imperative approach
        System.out.println("   Imperative (old way):");
        List<Integer> evenSquares = new ArrayList<>();
        for (Integer num : numbers) {
            if (num % 2 == 0) {
                evenSquares.add(num * num);
            }
        }
        System.out.println("   Even squares: " + evenSquares);

        // Declarative approach with streams
        System.out.println("\n   Declarative (streams):");
        List<Integer> evenSquaresStream = numbers.stream()
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                .collect(Collectors.toList());
        System.out.println("   Even squares: " + evenSquaresStream);
        System.out.println("   ✓ More readable, expresses WHAT not HOW\n");
    }

    private static void demonstrateComplexPipeline() {
        System.out.println("2. Complex Pipeline Example");

        List<Employee> employees = Arrays.asList(
                new Employee("Alice", "Engineering", 75000),
                new Employee("Bob", "Engineering", 85000),
                new Employee("Charlie", "Sales", 65000),
                new Employee("David", "Engineering", 95000),
                new Employee("Eve", "Sales", 70000));

        System.out.println("   Find top 2 Engineering salaries:");

        List<String> topEngineers = employees.stream()
                .filter(e -> e.department.equals("Engineering"))
                .sorted(Comparator.comparing(e -> -e.salary))
                .limit(2)
                .map(e -> e.name + " ($" + e.salary + ")")
                .collect(Collectors.toList());

        topEngineers.forEach(e -> System.out.println("   - " + e));
        System.out.println();
    }

    private static void demonstrateLazyEvaluation() {
        System.out.println("3. Lazy Evaluation");
        System.out.println("   Streams don't execute until terminal operation\n");

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        System.out.println("   Creating stream pipeline (no output yet):");
        Stream<Integer> stream = numbers.stream()
                .peek(n -> System.out.println("   - Filtering: " + n))
                .filter(n -> n % 2 == 0)
                .peek(n -> System.out.println("   - Mapping: " + n))
                .map(n -> n * n);

        System.out.println("\n   Now calling terminal operation (collect):");
        List<Integer> result = stream.collect(Collectors.toList());
        System.out.println("   Result: " + result);
        System.out.println("   ✓ Operations executed only when needed\n");
    }

    private static void demonstrateCollectors() {
        System.out.println("4. Powerful Collectors");

        List<Employee> employees = Arrays.asList(
                new Employee("Alice", "Engineering", 75000),
                new Employee("Bob", "Engineering", 85000),
                new Employee("Charlie", "Sales", 65000),
                new Employee("David", "Engineering", 95000),
                new Employee("Eve", "Sales", 70000));

        // Group by department
        Map<String, List<Employee>> byDept = employees.stream()
                .collect(Collectors.groupingBy(e -> e.department));

        System.out.println("   Employees grouped by department:");
        byDept.forEach((dept, emps) -> {
            System.out.println("   " + dept + ": " +
                    emps.stream().map(e -> e.name).collect(Collectors.joining(", ")));
        });

        // Average salary by department
        Map<String, Double> avgSalary = employees.stream()
                .collect(Collectors.groupingBy(
                        e -> e.department,
                        Collectors.averagingDouble(e -> e.salary)));

        System.out.println("\n   Average salary by department:");
        avgSalary.forEach((dept, avg) -> System.out.printf("   %s: $%.2f%n", dept, avg));
        System.out.println();
    }
}

class Employee {
    String name;
    String department;
    double salary;

    Employee(String name, String department, double salary) {
        this.name = name;
        this.department = department;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return name + " (" + department + ", $" + salary + ")";
    }
}