Streams

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

public class StreamIntro {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

        // Stream pipeline: source -> intermediate ops -> terminal op
        List<String> result = names.stream()          // Source: create stream from list
            .filter(n -> n.length() > 3)              // Intermediate: keep names longer than 3 chars
            .map(String::toUpperCase)                  // Intermediate: convert to uppercase
            .sorted()                                  // Intermediate: sort alphabetically
            .collect(Collectors.toList());             // Terminal: collect into a new list

        System.out.println("Result: " + result);
        // Output: Result: [ALICE, CHARLIE, DAVID]

        // The original list is unchanged
        System.out.println("Original: " + names);
        // Output: Original: [Alice, Bob, Charlie, David, Eve]

        // Streams are single-use -- this will throw IllegalStateException
        var stream = names.stream();
        stream.count(); // terminal operation consumes the stream
        // stream.forEach(System.out::println); // ERROR: stream has already been operated upon
    }
}

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

public class StreamFromCollections {
    public static void main(String[] args) {
        // From a List
        List<String> languages = List.of("Java", "Python", "Go", "Rust");
        List<String> filtered = languages.stream()
            .filter(lang -> lang.length() > 2)
            .collect(Collectors.toList());
        System.out.println("Filtered: " + filtered);
        // Output: Filtered: [Java, Python, Rust]

        // From a Set
        Set<Integer> numbers = new LinkedHashSet<>(Set.of(5, 3, 1, 4, 2));
        int sum = numbers.stream()
            .filter(n -> n % 2 != 0)
            .mapToInt(Integer::intValue)
            .sum();
        System.out.println("Sum of odds: " + sum);

        // From a Map (via entrySet, keySet, or values)
        Map<String, Integer> scores = Map.of("Alice", 92, "Bob", 78, "Charlie", 95);
        scores.entrySet().stream()
            .filter(e -> e.getValue() >= 90)
            .forEach(e -> System.out.println(e.getKey() + " scored " + e.getValue()));
        // Output: Alice scored 92
        //         Charlie scored 95
    }
}

import java.util.Arrays;
import java.util.stream.Stream;

public class StreamFromArrays {
    public static void main(String[] args) {
        String[] colors = {"Red", "Green", "Blue", "Yellow"};

        // Full array stream
        Arrays.stream(colors).forEach(System.out::println);

        // Partial array: from index 1 (inclusive) to 3 (exclusive)
        String[] partial = Arrays.stream(colors, 1, 3)
            .toArray(String[]::new);
        System.out.println(Arrays.toString(partial));
        // Output: [Green, Blue]

        // Stream.of() works with varargs
        Stream.of("One", "Two", "Three").forEach(System.out::println);

        // Primitive array -- returns IntStream, not Stream<Integer>
        int[] numbers = {10, 20, 30, 40};
        int sum = Arrays.stream(numbers).sum();
        System.out.println("Sum: " + sum); // Output: Sum: 100

        double avg = Arrays.stream(numbers).average().orElse(0.0);
        System.out.println("Average: " + avg); // Output: Average: 25.0
    }
}

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

public class StreamFactoryMethods {
    public static void main(String[] args) {
        // Stream.empty() -- useful as a return value instead of null
        Stream<String> empty = Stream.empty();
        System.out.println("Empty count: " + empty.count()); // Output: 0

        // Stream.of() -- create from individual elements
        Stream.of("Java", "Python", "Go")
            .map(String::toUpperCase)
            .forEach(System.out::println);

        // Stream.generate() -- infinite stream from a Supplier
        // ALWAYS use limit() or the stream runs forever
        List<String> uuids = Stream.generate(UUID::randomUUID)
            .limit(3)
            .map(UUID::toString)
            .collect(Collectors.toList());
        System.out.println("UUIDs: " + uuids);

        // Stream.iterate() -- Java 8 style (seed + UnaryOperator, must limit)
        List<Integer> powersOf2 = Stream.iterate(1, n -> n * 2)
            .limit(8)
            .collect(Collectors.toList());
        System.out.println("Powers: " + powersOf2);
        // Output: Powers: [1, 2, 4, 8, 16, 32, 64, 128]

        // Stream.iterate() -- Java 9+ style (seed + predicate + UnaryOperator)
        Stream.iterate(1, n -> n <= 100, n -> n * 2)
            .forEach(n -> System.out.print(n + " "));
        // Output: 1 2 4 8 16 32 64
        System.out.println();

        // Stream.concat() -- combine two streams into one
        Stream<String> s1 = Stream.of("A", "B");
        Stream<String> s2 = Stream.of("C", "D");
        Stream.concat(s1, s2).forEach(System.out::println);
        // Output: A, B, C, D
    }
}

import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class StreamRanges {
    public static void main(String[] args) {
        // range(start, endExclusive) -- does NOT include the end value
        IntStream.range(1, 5).forEach(n -> System.out.print(n + " "));
        // Output: 1 2 3 4
        System.out.println();

        // rangeClosed(start, endInclusive) -- INCLUDES the end value
        IntStream.rangeClosed(1, 5).forEach(n -> System.out.print(n + " "));
        // Output: 1 2 3 4 5
        System.out.println();

        // Sum of 1 to 100
        int sum = IntStream.rangeClosed(1, 100).sum();
        System.out.println("Sum 1-100: " + sum); // Output: Sum 1-100: 5050

        // LongStream for larger ranges
        long bigSum = LongStream.rangeClosed(1, 1_000_000).sum();
        System.out.println("Sum 1-1M: " + bigSum);
        // Output: Sum 1-1M: 500000500000

        // Using range as a loop replacement
        IntStream.range(0, 5)
            .mapToObj(i -> "Item " + i)
            .forEach(System.out::println);
    }
}

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

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

        // Keep only even numbers
        List<Integer> evens = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        System.out.println("Evens: " + evens);
        // Output: Evens: [2, 4, 6, 8, 10]

        // Chaining multiple filters (equivalent to AND)
        List<Integer> result = numbers.stream()
            .filter(n -> n > 3)
            .filter(n -> n < 8)
            .collect(Collectors.toList());
        System.out.println("Between 3 and 8: " + result);
        // Output: Between 3 and 8: [4, 5, 6, 7]

        // Filtering with complex predicates
        List<String> names = List.of("Alice", "Bob", "Charlie", "Anna", "Andrew");
        List<String> startsWithA = names.stream()
            .filter(name -> name.startsWith("A"))
            .filter(name -> name.length() > 4)
            .collect(Collectors.toList());
        System.out.println("Starts with A, length > 4: " + startsWithA);
        // Output: Starts with A, length > 4: [Alice, Andrew]
    }
}

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

public class MapExample {
    public static void main(String[] args) {
        // Transform strings to uppercase
        List<String> names = List.of("alice", "bob", "charlie");
        List<String> upper = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        System.out.println("Upper: " + upper);
        // Output: Upper: [ALICE, BOB, CHARLIE]

        // Transform to different type: String -> Integer (length)
        List<Integer> lengths = names.stream()
            .map(String::length)
            .collect(Collectors.toList());
        System.out.println("Lengths: " + lengths);
        // Output: Lengths: [5, 3, 7]

        // Chain map operations
        List<String> formatted = names.stream()
            .map(String::trim)
            .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))
            .map(s -> "Hello, " + s + "!")
            .collect(Collectors.toList());
        System.out.println("Formatted: " + formatted);
        // Output: Formatted: [Hello, Alice!, Hello, Bob!, Hello, Charlie!]

        // Extract a field from objects
        List<String> emails = List.of("alice@mail.com", "bob@mail.com", "charlie@mail.com");
        List<String> usernames = emails.stream()
            .map(email -> email.split("@")[0])
            .collect(Collectors.toList());
        System.out.println("Usernames: " + usernames);
        // Output: Usernames: [alice, bob, charlie]
    }
}

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

public class FlatMapExample {
    public static void main(String[] args) {
        // Problem: List of lists -- map gives Stream<List<String>>
        List<List<String>> nested = List.of(
            List.of("Java", "Python"),
            List.of("Go", "Rust"),
            List.of("JavaScript", "TypeScript")
        );

        // map() would give us Stream<List<String>> -- not what we want
        // flatMap() flattens it into Stream<String>
        List<String> allLanguages = nested.stream()
            .flatMap(List::stream)
            .collect(Collectors.toList());
        System.out.println("All: " + allLanguages);
        // Output: All: [Java, Python, Go, Rust, JavaScript, TypeScript]

        // Split sentences into words
        List<String> sentences = List.of(
            "Java is great",
            "Streams are powerful",
            "FlatMap flattens"
        );
        List<String> words = sentences.stream()
            .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
            .map(String::toLowerCase)
            .distinct()
            .sorted()
            .collect(Collectors.toList());
        System.out.println("Words: " + words);
        // Output: Words: [are, flatmap, flattens, great, is, java, powerful, streams]

        // flatMap with arrays
        String[][] data = {{"a", "b"}, {"c", "d"}, {"e", "f"}};
        List<String> flat = Arrays.stream(data)
            .flatMap(Arrays::stream)
            .collect(Collectors.toList());
        System.out.println("Flat: " + flat);
        // Output: Flat: [a, b, c, d, e, f]
    }
}

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

public class SortedExample {
    public static void main(String[] args) {
        List<String> names = List.of("Charlie", "Alice", "Eve", "Bob", "David");

        // Natural ordering (alphabetical for Strings)
        List<String> sorted = names.stream()
            .sorted()
            .collect(Collectors.toList());
        System.out.println("Sorted: " + sorted);
        // Output: Sorted: [Alice, Bob, Charlie, David, Eve]

        // Reverse order
        List<String> reversed = names.stream()
            .sorted(Comparator.reverseOrder())
            .collect(Collectors.toList());
        System.out.println("Reversed: " + reversed);
        // Output: Reversed: [Eve, David, Charlie, Bob, Alice]

        // Sort by length
        List<String> byLength = names.stream()
            .sorted(Comparator.comparingInt(String::length))
            .collect(Collectors.toList());
        System.out.println("By length: " + byLength);
        // Output: By length: [Bob, Eve, Alice, David, Charlie]

        // Sort by length descending, then alphabetically
        List<String> complex = names.stream()
            .sorted(Comparator.comparingInt(String::length)
                .reversed()
                .thenComparing(Comparator.naturalOrder()))
            .collect(Collectors.toList());
        System.out.println("Complex sort: " + complex);
        // Output: Complex sort: [Charlie, Alice, David, Bob, Eve]
    }
}

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

public class MoreIntermediateOps {
    public static void main(String[] args) {
        // distinct() -- removes duplicates
        List<Integer> numbers = List.of(1, 2, 3, 2, 1, 4, 3, 5);
        List<Integer> unique = numbers.stream()
            .distinct()
            .collect(Collectors.toList());
        System.out.println("Unique: " + unique);
        // Output: Unique: [1, 2, 3, 4, 5]

        // peek() -- inspect elements without consuming (great for debugging)
        List<String> result = List.of("one", "two", "three", "four").stream()
            .filter(s -> s.length() > 3)
            .peek(s -> System.out.println("After filter: " + s))
            .map(String::toUpperCase)
            .peek(s -> System.out.println("After map: " + s))
            .collect(Collectors.toList());
        // Output:
        // After filter: three
        // After map: THREE
        // After filter: four
        // After map: FOUR
        System.out.println("Result: " + result);
        // Output: Result: [THREE, FOUR]

        // limit(n) -- take only the first n elements
        List<Integer> firstThree = List.of(10, 20, 30, 40, 50).stream()
            .limit(3)
            .collect(Collectors.toList());
        System.out.println("First 3: " + firstThree);
        // Output: First 3: [10, 20, 30]

        // skip(n) -- skip the first n elements
        List<Integer> skipTwo = List.of(10, 20, 30, 40, 50).stream()
            .skip(2)
            .collect(Collectors.toList());
        System.out.println("Skip 2: " + skipTwo);
        // Output: Skip 2: [30, 40, 50]

        // Pagination: skip + limit
        List<String> allItems = List.of("A", "B", "C", "D", "E", "F", "G", "H");
        int pageSize = 3;
        int pageNumber = 2; // 0-based
        List<String> page = allItems.stream()
            .skip((long) pageNumber * pageSize)
            .limit(pageSize)
            .collect(Collectors.toList());
        System.out.println("Page 2: " + page);
        // Output: Page 2: [G, H]
    }
}

import java.util.List;

public class ForEachExample {
    public static void main(String[] args) {
        List<String> fruits = List.of("Apple", "Banana", "Cherry");

        // forEach -- order guaranteed for sequential streams
        fruits.stream().forEach(f -> System.out.println("Fruit: " + f));

        // Method reference shorthand
        fruits.stream().forEach(System.out::println);

        // forEachOrdered -- guarantees encounter order even in parallel
        fruits.parallelStream().forEachOrdered(System.out::println);
        // Output (always in order): Apple, Banana, Cherry
    }
}

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

public class CollectExample {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie", "Alice", "David");

        // Collect to List
        List<String> list = names.stream()
            .filter(n -> n.length() > 3)
            .collect(Collectors.toList());
        System.out.println("List: " + list);
        // Output: List: [Alice, Charlie, Alice, David]

        // Collect to Set (removes duplicates)
        Set<String> set = names.stream()
            .collect(Collectors.toSet());
        System.out.println("Set: " + set);

        // Collect to Map
        Map<String, Integer> nameLengths = names.stream()
            .distinct()
            .collect(Collectors.toMap(
                name -> name,         // key
                String::length        // value
            ));
        System.out.println("Map: " + nameLengths);
        // Output: Map: {Alice=5, Bob=3, Charlie=7, David=5}

        // Join strings
        String joined = names.stream()
            .distinct()
            .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("Joined: " + joined);
        // Output: Joined: [Alice, Bob, Charlie, David]
    }
}

import java.util.List;
import java.util.Optional;

public class ReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // reduce with identity -- always returns a value
        int sum = numbers.stream()
            .reduce(0, Integer::sum);
        System.out.println("Sum: " + sum); // Output: Sum: 15

        int product = numbers.stream()
            .reduce(1, (a, b) -> a * b);
        System.out.println("Product: " + product); // Output: Product: 120

        // reduce without identity -- returns Optional (stream could be empty)
        Optional<Integer> max = numbers.stream()
            .reduce(Integer::max);
        max.ifPresent(m -> System.out.println("Max: " + m)); // Output: Max: 5

        // Concatenating strings with reduce
        List<String> words = List.of("Java", "Streams", "Are", "Powerful");
        String sentence = words.stream()
            .reduce("", (a, b) -> a.isEmpty() ? b : a + " " + b);
        System.out.println("Sentence: " + sentence);
        // Output: Sentence: Java Streams Are Powerful

        // reduce on empty stream
        Optional<Integer> emptyResult = List.<Integer>of().stream()
            .reduce(Integer::sum);
        System.out.println("Empty: " + emptyResult.isPresent()); // Output: Empty: false
    }
}

import java.util.Comparator;
import java.util.List;
import java.util.Optional;

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

        // count()
        long count = numbers.stream()
            .filter(n -> n > 5)
            .count();
        System.out.println("Count > 5: " + count); // Output: Count > 5: 3

        // min() with Comparator
        Optional<Integer> min = numbers.stream()
            .min(Comparator.naturalOrder());
        System.out.println("Min: " + min.orElse(-1)); // Output: Min: 1

        // max() with Comparator
        Optional<Integer> max = numbers.stream()
            .max(Comparator.naturalOrder());
        System.out.println("Max: " + max.orElse(-1)); // Output: Max: 9

        // Finding the longest string
        List<String> words = List.of("cat", "elephant", "dog", "hippopotamus");
        Optional<String> longest = words.stream()
            .max(Comparator.comparingInt(String::length));
        System.out.println("Longest: " + longest.orElse("none"));
        // Output: Longest: hippopotamus
    }
}

import java.util.List;
import java.util.Optional;

public class FindExample {
    public static void main(String[] args) {
        List<String> names = List.of("Charlie", "Alice", "Bob", "Andrew", "Anna");

        // findFirst() -- guaranteed to return the first matching element
        Optional<String> first = names.stream()
            .filter(n -> n.startsWith("A"))
            .findFirst();
        System.out.println("First with A: " + first.orElse("none"));
        // Output: First with A: Alice

        // findAny() -- may return any matching element (non-deterministic in parallel)
        Optional<String> any = names.parallelStream()
            .filter(n -> n.startsWith("A"))
            .findAny();
        System.out.println("Any with A: " + any.orElse("none"));
        // Output: Any with A: Alice (or Andrew or Anna -- non-deterministic)

        // findFirst on empty result
        Optional<String> missing = names.stream()
            .filter(n -> n.startsWith("Z"))
            .findFirst();
        System.out.println("Found Z? " + missing.isPresent());
        // Output: Found Z? false
    }
}

import java.util.List;

public class MatchExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(2, 4, 6, 8, 10);

        // anyMatch -- does at least one element match?
        boolean hasEven = numbers.stream().anyMatch(n -> n % 2 == 0);
        System.out.println("Has even? " + hasEven); // Output: Has even? true

        // allMatch -- do ALL elements match?
        boolean allEven = numbers.stream().allMatch(n -> n % 2 == 0);
        System.out.println("All even? " + allEven); // Output: All even? true

        // noneMatch -- does NO element match?
        boolean noneNegative = numbers.stream().noneMatch(n -> n < 0);
        System.out.println("None negative? " + noneNegative); // Output: None negative? true

        // Short-circuiting behavior
        List<Integer> mixed = List.of(1, 2, 3, 4, 5);
        boolean anyOver3 = mixed.stream()
            .peek(n -> System.out.print("Checking " + n + "... "))
            .anyMatch(n -> n > 3);
        System.out.println("\nAny over 3? " + anyOver3);
        // Output: Checking 1... Checking 2... Checking 3... Checking 4...
        //         Any over 3? true
        // Note: 5 was never checked -- short-circuited after finding 4
    }
}

import java.util.Arrays;
import java.util.List;

public class ToArrayExample {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie");

        // toArray() without argument -- returns Object[]
        Object[] objArray = names.stream().toArray();
        System.out.println(Arrays.toString(objArray));

        // toArray with generator -- returns String[]
        String[] strArray = names.stream()
            .map(String::toUpperCase)
            .toArray(String[]::new);
        System.out.println(Arrays.toString(strArray));
        // Output: [ALICE, BOB, CHARLIE]

        // Convert filtered stream to int array
        int[] evenNumbers = List.of(1, 2, 3, 4, 5, 6).stream()
            .filter(n -> n % 2 == 0)
            .mapToInt(Integer::intValue)
            .toArray();
        System.out.println(Arrays.toString(evenNumbers));
        // Output: [2, 4, 6]
    }
}

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

public class BasicCollectors {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie", "Alice", "David");

        // toList() -- ordered, allows duplicates
        List<String> list = names.stream()
            .filter(n -> n.length() > 3)
            .collect(Collectors.toList());
        System.out.println("List: " + list);
        // Output: List: [Alice, Charlie, Alice, David]

        // toSet() -- unordered, no duplicates
        Set<String> set = names.stream()
            .collect(Collectors.toSet());
        System.out.println("Set: " + set);

        // toMap() -- key-value pairs
        Map<String, Integer> nameLengths = names.stream()
            .distinct()
            .collect(Collectors.toMap(
                n -> n,              // key mapper
                String::length       // value mapper
            ));
        System.out.println("Map: " + nameLengths);

        // toMap() with merge function for duplicate keys
        Map<String, Integer> nameCount = names.stream()
            .collect(Collectors.toMap(
                n -> n,              // key
                n -> 1,              // value
                Integer::sum         // merge: add counts
            ));
        System.out.println("Counts: " + nameCount);
        // Output: Counts: {Alice=2, Bob=1, Charlie=1, David=1}
    }
}

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

public class JoiningCollector {
    public static void main(String[] args) {
        List<String> languages = List.of("Java", "Python", "Go", "Rust");

        // Simple concatenation
        String simple = languages.stream().collect(Collectors.joining());
        System.out.println(simple); // Output: JavaPythonGoRust

        // With delimiter
        String delimited = languages.stream().collect(Collectors.joining(", "));
        System.out.println(delimited); // Output: Java, Python, Go, Rust

        // With delimiter, prefix, and suffix
        String formatted = languages.stream()
            .collect(Collectors.joining(" | ", "[ ", " ]"));
        System.out.println(formatted); // Output: [ Java | Python | Go | Rust ]

        // Practical: building a SQL IN clause
        List<Integer> ids = List.of(101, 205, 310, 422);
        String inClause = ids.stream()
            .map(String::valueOf)
            .collect(Collectors.joining(", ", "WHERE id IN (", ")"));
        System.out.println(inClause);
        // Output: WHERE id IN (101, 205, 310, 422)
    }
}

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

public class GroupingExample {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Anna", "Bob", "Brian", "Charlie", "Chris");

        // Group by first letter
        Map<Character, List<String>> byLetter = names.stream()
            .collect(Collectors.groupingBy(n -> n.charAt(0)));
        System.out.println("By letter: " + byLetter);
        // Output: By letter: {A=[Alice, Anna], B=[Bob, Brian], C=[Charlie, Chris]}

        // Group by length with counting
        Map<Integer, Long> byLength = names.stream()
            .collect(Collectors.groupingBy(String::length, Collectors.counting()));
        System.out.println("By length: " + byLength);
        // Output: By length: {3=1, 4=1, 5=3, 7=1}

        // partitioningBy -- split into two groups
        Map<Boolean, List<String>> partitioned = names.stream()
            .collect(Collectors.partitioningBy(n -> n.length() > 4));
        System.out.println("Long names: " + partitioned.get(true));
        System.out.println("Short names: " + partitioned.get(false));
        // Output: Long names: [Alice, Brian, Charlie, Chris]
        //         Short names: [Anna, Bob]
    }
}

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

public class ParallelStreamExample {
    public static void main(String[] args) {
        // Creating a parallel stream
        List<Integer> numbers = IntStream.rangeClosed(1, 1_000_000)
            .boxed()
            .collect(Collectors.toList());

        // Sequential sum
        long startSeq = System.nanoTime();
        long sumSeq = numbers.stream()
            .mapToLong(Integer::longValue)
            .sum();
        long timeSeq = System.nanoTime() - startSeq;

        // Parallel sum
        long startPar = System.nanoTime();
        long sumPar = numbers.parallelStream()
            .mapToLong(Integer::longValue)
            .sum();
        long timePar = System.nanoTime() - startPar;

        System.out.println("Sequential sum: " + sumSeq + " in " + timeSeq / 1_000_000 + "ms");
        System.out.println("Parallel sum:   " + sumPar + " in " + timePar / 1_000_000 + "ms");

        // Converting between sequential and parallel
        List<String> names = List.of("Alice", "Bob", "Charlie");
        names.stream()
            .parallel()    // switch to parallel
            .sequential()  // switch back to sequential
            .forEach(System.out::println);
    }
}

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

public class ParallelSafetyExample {
    public static void main(String[] args) {
        // WRONG: Modifying a shared list from parallel stream
        List<Integer> unsafeList = new ArrayList<>();
        IntStream.rangeClosed(1, 10000)
            .parallel()
            .forEach(unsafeList::add); // Race condition!
        System.out.println("Unsafe size: " + unsafeList.size());
        // Output: unpredictable -- could be less than 10000, could throw exception

        // CORRECT: Use collect() instead of modifying shared state
        List<Integer> safeList = IntStream.rangeClosed(1, 10000)
            .parallel()
            .boxed()
            .collect(Collectors.toList());
        System.out.println("Safe size: " + safeList.size());
        // Output: Safe size: 10000

        // CORRECT: Use a synchronized collection if you must
        List<Integer> syncList = Collections.synchronizedList(new ArrayList<>());
        IntStream.rangeClosed(1, 10000)
            .parallel()
            .forEach(syncList::add);
        System.out.println("Sync size: " + syncList.size());
        // Output: Sync size: 10000
    }
}

import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.stream.IntStream;

public class PrimitiveStreamExample {
    public static void main(String[] args) {
        // IntStream basics
        int sum = IntStream.of(10, 20, 30, 40, 50).sum();
        System.out.println("Sum: " + sum); // Output: Sum: 150

        OptionalDouble avg = IntStream.of(10, 20, 30, 40, 50).average();
        System.out.println("Average: " + avg.orElse(0.0)); // Output: Average: 30.0

        OptionalInt min = IntStream.of(10, 20, 30, 40, 50).min();
        System.out.println("Min: " + min.orElse(-1)); // Output: Min: 10

        OptionalInt max = IntStream.of(10, 20, 30, 40, 50).max();
        System.out.println("Max: " + max.orElse(-1)); // Output: Max: 50

        // summaryStatistics -- get all stats in one pass
        IntSummaryStatistics stats = IntStream.of(10, 20, 30, 40, 50)
            .summaryStatistics();
        System.out.println("Count: " + stats.getCount());     // 5
        System.out.println("Sum: " + stats.getSum());         // 150
        System.out.println("Min: " + stats.getMin());         // 10
        System.out.println("Max: " + stats.getMax());         // 50
        System.out.println("Avg: " + stats.getAverage());     // 30.0

        // mapToInt -- convert Stream<String> to IntStream
        List<String> words = List.of("Java", "is", "powerful");
        int totalChars = words.stream()
            .mapToInt(String::length)
            .sum();
        System.out.println("Total chars: " + totalChars); // Output: Total chars: 15

        // boxed() -- convert IntStream back to Stream<Integer>
        List<Integer> boxed = IntStream.rangeClosed(1, 5)
            .boxed()
            .toList();
        System.out.println("Boxed: " + boxed); // Output: Boxed: [1, 2, 3, 4, 5]
    }
}

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

public class BestPracticeSimple {
    public static void main(String[] args) {
        List<String> emails = List.of(
            "alice@GMAIL.com", "  bob@yahoo.com  ", "CHARLIE@gmail.com", "invalid-email"
        );

        // BAD: Complex logic crammed into one lambda
        List<String> bad = emails.stream()
            .filter(e -> {
                String trimmed = e.trim().toLowerCase();
                return trimmed.contains("@") && trimmed.endsWith(".com");
            })
            .map(e -> e.trim().toLowerCase())
            .collect(Collectors.toList());

        // GOOD: Extract complex logic into named methods
        List<String> good = emails.stream()
            .map(String::trim)
            .map(String::toLowerCase)
            .filter(BestPracticeSimple::isValidEmail)
            .collect(Collectors.toList());

        System.out.println("Valid emails: " + good);
        // Output: Valid emails: [alice@gmail.com, bob@yahoo.com, charlie@gmail.com]
    }

    private static boolean isValidEmail(String email) {
        return email.contains("@") && email.endsWith(".com");
    }
}

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

public class BestPracticeNoSideEffects {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie");

        // BAD: Side effect in map() -- modifying an external list
        List<String> external = new ArrayList<>();
        names.stream()
            .map(n -> {
                external.add(n); // Side effect -- do not do this!
                return n.toUpperCase();
            })
            .collect(Collectors.toList());

        // GOOD: Use collect() to build the result
        List<String> result = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        System.out.println("Result: " + result);
        // Output: Result: [ALICE, BOB, CHARLIE]
    }
}

import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class BestPracticeNoReuse {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie");

        // BAD: Reusing a stream
        Stream<String> stream = names.stream().filter(n -> n.length() > 3);
        stream.forEach(System.out::println);  // works
        // stream.count();  // IllegalStateException: stream has already been operated upon

        // GOOD: Create a new stream each time
        long count = names.stream().filter(n -> n.length() > 3).count();
        List<String> filtered = names.stream()
            .filter(n -> n.length() > 3)
            .collect(Collectors.toList());

        // ALTERNATIVE: Use a Supplier<Stream> for repeated use
        Supplier<Stream<String>> streamSupplier = () ->
            names.stream().filter(n -> n.length() > 3);

        long count2 = streamSupplier.get().count();
        List<String> list2 = streamSupplier.get().collect(Collectors.toList());
        System.out.println("Count: " + count2 + ", List: " + list2);
    }
}

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

public class BestPracticeOrder {
    public static void main(String[] args) {
        List<String> names = List.of("Charlie", "Alice", "Eve", "Bob", "David",
            "Frank", "Grace", "Hannah", "Ivy", "Jack");

        // BAD: Sort everything, then filter
        List<String> bad = names.stream()
            .sorted()                            // sorts all 10 elements
            .filter(n -> n.length() > 3)         // then filters
            .map(String::toUpperCase)
            .collect(Collectors.toList());

        // GOOD: Filter first, then sort the smaller set
        List<String> good = names.stream()
            .filter(n -> n.length() > 3)         // filters to 7 elements
            .sorted()                            // sorts only 7 elements
            .map(String::toUpperCase)
            .collect(Collectors.toList());

        System.out.println("Result: " + good);
        // Output: Result: [ALICE, CHARLIE, DAVID, FRANK, GRACE, HANNAH]
    }
}

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

public class StreamVsLoop {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie", "Anna", "David", "Andrew");

        // --- STREAM WINS: Filter + Transform + Collect ---

        // Stream approach -- clean, declarative
        List<String> streamResult = names.stream()
            .filter(n -> n.startsWith("A"))
            .map(String::toUpperCase)
            .sorted()
            .collect(Collectors.toList());

        // Loop approach -- more verbose
        List<String> loopResult = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("A")) {
                loopResult.add(name.toUpperCase());
            }
        }
        java.util.Collections.sort(loopResult);

        System.out.println("Stream: " + streamResult);
        System.out.println("Loop:   " + loopResult);

        // --- STREAM WINS: Grouping ---
        Map<Character, List<String>> grouped = names.stream()
            .collect(Collectors.groupingBy(n -> n.charAt(0)));
        System.out.println("Grouped: " + grouped);
        // This would take 10+ lines with loops

        // --- LOOP WINS: Early exit with break ---
        String found = null;
        for (String name : names) {
            if (name.length() > 5) {
                found = name;
                break; // Stream alternative: findFirst(), but less flexible
            }
        }
        System.out.println("Found: " + found);

        // --- LOOP WINS: Index-based access ---
        for (int i = 0; i < names.size(); i++) {
            System.out.println(i + ": " + names.get(i));
        }
    }
}

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

public class EmployeeAnalytics {

    enum Department { ENGINEERING, MARKETING, SALES, HR, FINANCE }

    record Employee(String name, Department department, double salary, int yearsOfExperience) {}

    public static void main(String[] args) {
        List<Employee> employees = List.of(
            new Employee("Alice",   Department.ENGINEERING, 95000, 5),
            new Employee("Bob",     Department.ENGINEERING, 110000, 8),
            new Employee("Charlie", Department.MARKETING,   72000, 3),
            new Employee("Diana",   Department.SALES,       68000, 2),
            new Employee("Eve",     Department.ENGINEERING, 125000, 12),
            new Employee("Frank",   Department.HR,          65000, 4),
            new Employee("Grace",   Department.FINANCE,     88000, 6),
            new Employee("Hannah",  Department.MARKETING,   78000, 5),
            new Employee("Ivan",    Department.SALES,       71000, 3),
            new Employee("Julia",   Department.FINANCE,     92000, 7),
            new Employee("Kevin",   Department.HR,          60000, 1),
            new Employee("Laura",   Department.ENGINEERING, 105000, 9),
            new Employee("Mike",    Department.SALES,       75000, 4),
            new Employee("Nina",    Department.MARKETING,   82000, 6),
            new Employee("Oscar",   Department.FINANCE,     97000, 8)
        );

        // 1. Total salary expense
        double totalSalary = employees.stream()
            .mapToDouble(Employee::salary)
            .sum();
        System.out.println("Total salary expense: $" + String.format("%,.2f", totalSalary));

        // 2. Average salary
        double avgSalary = employees.stream()
            .mapToDouble(Employee::salary)
            .average()
            .orElse(0.0);
        System.out.println("Average salary: $" + String.format("%,.2f", avgSalary));

        // 3. Highest paid employee
        employees.stream()
            .max(Comparator.comparingDouble(Employee::salary))
            .ifPresent(e -> System.out.println("Highest paid: " + e.name() + " ($" +
                String.format("%,.2f", e.salary()) + ")"));

        // 4. Employees earning above average
        List<String> aboveAverage = employees.stream()
            .filter(e -> e.salary() > avgSalary)
            .sorted(Comparator.comparingDouble(Employee::salary).reversed())
            .map(e -> e.name() + " ($" + String.format("%,.2f", e.salary()) + ")")
            .collect(Collectors.toList());
        System.out.println("Above average: " + aboveAverage);

        // 5. Group by department
        Map<Department, List<String>> byDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::department,
                Collectors.mapping(Employee::name, Collectors.toList())
            ));
        System.out.println("\nEmployees by department:");
        byDept.forEach((dept, names) ->
            System.out.println("  " + dept + ": " + names));

        // 6. Average salary by department
        Map<Department, Double> avgByDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::department,
                Collectors.averagingDouble(Employee::salary)
            ));
        System.out.println("\nAverage salary by department:");
        avgByDept.entrySet().stream()
            .sorted(Map.Entry.<Department, Double>comparingByValue().reversed())
            .forEach(e -> System.out.println("  " + e.getKey() + ": $" +
                String.format("%,.2f", e.getValue())));

        // 7. Department with highest average salary
        avgByDept.entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .ifPresent(e -> System.out.println("\nHighest avg dept: " + e.getKey() +
                " ($" + String.format("%,.2f", e.getValue()) + ")"));

        // 8. Count employees per department
        Map<Department, Long> countByDept = employees.stream()
            .collect(Collectors.groupingBy(Employee::department, Collectors.counting()));
        System.out.println("\nHeadcount by department: " + countByDept);

        // 9. Partition into senior (5+ years) and junior
        Map<Boolean, List<Employee>> seniorPartition = employees.stream()
            .collect(Collectors.partitioningBy(e -> e.yearsOfExperience() >= 5));
        System.out.println("\nSenior employees (5+ years):");
        seniorPartition.get(true).forEach(e ->
            System.out.println("  " + e.name() + " - " + e.yearsOfExperience() + " years"));
        System.out.println("Junior employees (< 5 years):");
        seniorPartition.get(false).forEach(e ->
            System.out.println("  " + e.name() + " - " + e.yearsOfExperience() + " years"));

        // 10. Salary statistics by department
        System.out.println("\nSalary statistics by department:");
        employees.stream()
            .collect(Collectors.groupingBy(
                Employee::department,
                Collectors.summarizingDouble(Employee::salary)
            ))
            .forEach((dept, stats) -> System.out.printf(
                "  %s: count=%d, min=$%,.0f, max=$%,.0f, avg=$%,.0f, total=$%,.0f%n",
                dept, stats.getCount(), stats.getMin(), stats.getMax(),
                stats.getAverage(), stats.getSum()));

        // 11. Top 3 earners across the company
        System.out.println("\nTop 3 earners:");
        employees.stream()
            .sorted(Comparator.comparingDouble(Employee::salary).reversed())
            .limit(3)
            .forEach(e -> System.out.println("  " + e.name() + " - $" +
                String.format("%,.2f", e.salary())));

        // 12. Build a salary report string
        String report = employees.stream()
            .sorted(Comparator.comparing(Employee::name))
            .map(e -> String.format("%-10s | %-12s | $%,10.2f | %2d yrs",
                e.name(), e.department(), e.salary(), e.yearsOfExperience()))
            .collect(Collectors.joining("\n"));
        System.out.println("\n--- Employee Report ---");
        System.out.println(String.format("%-10s | %-12s | %11s | %s",
            "Name", "Department", "Salary", "Experience"));
        System.out.println("-".repeat(55));
        System.out.println(report);
    }
}