// Form 1: No parameters
Runnable r = () -> System.out.println("Running!");

// Form 2: Single parameter (parens optional)
Consumer<String> print = s -> System.out.println(s);

// Form 3: Multiple parameters
Comparator<Integer> cmp = (a, b) -> a - b;

// Form 4: Block body (multiple statements, explicit return)
Function<String, String> format = name -> {
    String trimmed = name.trim();
    return trimmed.substring(0, 1).toUpperCase() + trimmed.substring(1);
};

// Form 5: With explicit types (rarely needed — compiler infers)
BiFunction<Integer, Integer, Integer> add = (Integer x, Integer y) -> x + y;

int threshold = 5;  // effectively final — never reassigned

Predicate<String> longEnough = s -> s.length() > threshold;  // ✅ OK

threshold = 10;  // now reassigned — lambda above would fail to compile

// ❌ This does NOT compile:
int count = 0;
list.forEach(s -> count++);  // ERROR: count is not effectively final

// ✅ Use AtomicInteger for mutable counters in lambdas:
AtomicInteger count = new AtomicInteger(0);
list.forEach(s -> count.incrementAndGet());

public class MyClass {
    private String name = "MyClass";

    void demo() {
        // Anonymous class: 'this' refers to the anonymous class instance
        Runnable anon = new Runnable() {
            public void run() {
                System.out.println(this);  // prints anonymous class
            }
        };

        // Lambda: 'this' refers to the ENCLOSING class (MyClass)
        Runnable lam = () -> System.out.println(this.name);  // "MyClass"
    }
}

// Predicate — test a condition
Predicate<Integer> isEven = n -> n % 2 == 0;
isEven.test(4);   // true
isEven.test(7);   // false

// Function — transform a value
Function<String, Integer> strLen = String::length;
strLen.apply("hello");  // 5

// Consumer — do something, return nothing
Consumer<String> logger = msg -> System.out.println("[LOG] " + msg);
logger.accept("Started");  // prints [LOG] Started

// Supplier — produce a value from nothing
Supplier<List<String>> listFactory = ArrayList::new;
List<String> list = listFactory.get();  // fresh list each call

Function<String, String> trim = String::trim;
Function<String, String> upper = String::toUpperCase;

// andThen: trim first, THEN uppercase
Function<String, String> clean = trim.andThen(upper);
clean.apply("  hello  ");  // "HELLO"

// Predicate composition
Predicate<String> notEmpty = s -> !s.isEmpty();
Predicate<String> notBlank = s -> !s.isBlank();
Predicate<String> valid = notEmpty.and(notBlank);

// UnaryOperator — Function<T,T> shorthand
UnaryOperator<Integer> doubleIt = n -> n * 2;
UnaryOperator<Integer> addTen  = n -> n + 10;
UnaryOperator<Integer> doubleThenAdd = doubleIt.andThen(addTen);
doubleThenAdd.apply(5);  // (5*2)+10 = 20

@FunctionalInterface  // optional but documents intent; compiler enforces 1 abstract method
public interface TriFunction<A, B, C, R> {
    R apply(A a, B b, C c);
}

TriFunction<Integer, Integer, Integer, Integer> clamp =
    (val, min, max) -> Math.min(Math.max(val, min), max);

clamp.apply(150, 0, 100);  // 100

// 1. Static method reference
Function<String, Integer> parseInt = Integer::parseInt;
parseInt.apply("42");  // 42

// 2. Bound instance method reference (specific object)
String prefix = "Hello, ";
Function<String, String> greet = prefix::concat;
greet.apply("World");  // "Hello, World"

// 3. Unbound instance method reference (applied to argument)
Function<String, String> toUpper = String::toUpperCase;
toUpper.apply("java");  // "JAVA"

// 4. Constructor reference
Function<String, StringBuilder> sbFactory = StringBuilder::new;
StringBuilder sb = sbFactory.apply("initial");

// In streams — this is where they really shine
List<String> names = List.of("alice", "bob", "charlie");
names.stream()
     .map(String::toUpperCase)        // unbound instance
     .forEach(System.out::println);    // bound to System.out

// From a Collection
Stream<String> s1 = names.stream();

// From values directly
Stream<String> s2 = Stream.of("a", "b", "c");

// From an array
Stream<String> s3 = Arrays.stream(namesArray);

// Infinite stream — generates values on demand
Stream<Integer> naturals = Stream.iterate(1, n -> n + 1);

// Range of integers (use IntStream for primitives — no boxing)
IntStream range = IntStream.rangeClosed(1, 10);  // 1 to 10 inclusive

// From a file
Stream<String> lines = Files.lines(Path.of("data.txt"));  // remember to close!

Stream.of("Alice", "Bob", "Charlie", "Dave")
    .filter(s -> {
        System.out.println("filter: " + s);
        return s.length() > 3;
    })
    .map(s -> {
        System.out.println("map: " + s);
        return s.toUpperCase();
    })
    .findFirst();  // terminal operation

// Output: filter: Alice → map: Alice → (done — found it!)
// Bob/Charlie/Dave are never even processed

List<String> words = List.of("stream", "lambda", "java", "stream", "api");

List<String> result = words.stream()
    .filter(w -> w.length() > 3)      // ["stream","lambda","java","stream"]
    .distinct()                          // ["stream","lambda","java"]
    .sorted()                            // ["java","lambda","stream"]
    .map(String::toUpperCase)            // ["JAVA","LAMBDA","STREAM"]
    .limit(2)                           // ["JAVA","LAMBDA"]
    .collect(Collectors.toList());

// peek() for debugging — inspect without changing the stream
List<Integer> lengths = words.stream()
    .filter(w -> w.length() > 3)
    .peek(w -> System.out.println("After filter: " + w))
    .map(String::length)
    .peek(n -> System.out.println("After map: " + n))
    .collect(Collectors.toList());

// Stream<Integer> — boxes each int (slow for large data)
int total = words.stream()
    .map(String::length)        // Stream<Integer>
    .reduce(0, Integer::sum);

// IntStream — no boxing (fast)
int total = words.stream()
    .mapToInt(String::length)   // IntStream
    .sum();                       // IntStream has sum(), average(), min(), max() built in

// IntStream statistics
IntSummaryStatistics stats = words.stream()
    .mapToInt(String::length)
    .summaryStatistics();
stats.getAverage();  // 4.8
stats.getMax();      // 6

List<Integer> nums = List.of(1, 2, 3, 4, 5);

// reduce(identity, accumulator)
int sum = nums.stream().reduce(0, (acc, n) -> acc + n);  // 15
int product = nums.stream().reduce(1, (acc, n) -> acc * n);  // 120

// Without identity — returns Optional (stream might be empty)
Optional<Integer> max = nums.stream().reduce(Integer::max);

// Shorthand methods on IntStream
nums.stream().mapToInt(Integer::intValue).sum();
nums.stream().mapToInt(Integer::intValue).average();  // OptionalDouble
nums.stream().mapToInt(Integer::intValue).min();
nums.stream().mapToInt(Integer::intValue).max();

List<String> names = List.of("Alice", "Bob", "Charlie");

// findFirst — returns first element matching pipeline (Optional)
Optional<String> first = names.stream()
    .filter(s -> s.startsWith("C"))
    .findFirst();  // Optional["Charlie"]

// anyMatch / allMatch / noneMatch — return boolean
boolean anyLong  = names.stream().anyMatch(s -> s.length() > 4);  // true
boolean allShort = names.stream().allMatch(s -> s.length() < 10); // true
boolean noneNum  = names.stream().noneMatch(s -> s.matches("\\d+"));  // true

// count — number of elements after pipeline
long longNames = names.stream().filter(s -> s.length() > 3).count();  // 2

// Good: printing, logging, storing to external system
names.stream()
     .filter(s -> s.length() > 3)
     .forEach(System.out::println);

// ❌ Bad: modifying a collection inside forEach (side-effect anti-pattern)
List<String> result = new ArrayList<>();
names.stream()
     .filter(s -> s.length() > 3)
     .forEach(result::add);  // works but defeats the purpose — use collect instead

// ✅ Good: use collect for building collections
List<String> result = names.stream()
     .filter(s -> s.length() > 3)
     .collect(Collectors.toList());

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

List<String> names = List.of("Alice", "Bob", "Alice", "Charlie");

// toList() — ordered, allows duplicates
List<String> list = names.stream().collect(toList());

// toSet() — no duplicates, unordered
Set<String> set = names.stream().collect(toSet());  // {"Alice","Bob","Charlie"}

// joining() — concatenate strings
String csv = names.stream().collect(joining(", "));  // "Alice, Bob, Alice, Charlie"
String fmt = names.stream().collect(joining(", ", "[", "]"));  // "[Alice, Bob, Alice, Charlie]"

// counting() — count elements
long n = names.stream().collect(counting());  // 4

// Java 16+: toList() as terminal op directly (immutable)
List<String> immutable = names.stream().filter(s -> s.length() > 3).toList();

List<String> words = List.of("cat", "car", "dog", "deer", "duck");

// Group by first letter → Map<Character, List<String>>
Map<Character, List<String>> byLetter = words.stream()
    .collect(groupingBy(s -> s.charAt(0)));
// {c=[cat,car], d=[dog,deer,duck]}

// Group and count instead of listing
Map<Character, Long> countByLetter = words.stream()
    .collect(groupingBy(s -> s.charAt(0), counting()));
// {c=2, d=3}

// Group employees by department, collect to names only
Map<String, List<String>> namesByDept = employees.stream()
    .collect(groupingBy(
        Employee::getDepartment,
        mapping(Employee::getName, toList())
    ));

// partitioningBy — special groupingBy for boolean split
Map<Boolean, List<Integer>> evenOdd = nums.stream()
    .collect(partitioningBy(n -> n % 2 == 0));
// {true=[2,4], false=[1,3,5]}

// toMap — build a Map from stream elements
Map<String, Integer> wordLengths = words.stream()
    .collect(toMap(
        w -> w,             // key: the word itself
        String::length      // value: its length
    ));
// {cat=3, car=3, dog=3, deer=4, duck=4}

// toMap with merge function (handles duplicate keys)
Map<Integer, String> lengthToWords = words.stream()
    .collect(toMap(
        String::length,
        w -> w,
        (existing, newVal) -> existing + "," + newVal  // merge on collision
    ));

List<String> sentences = List.of("hello world", "java streams");

// map gives Stream<String[]> — nested, not useful
sentences.stream().map(s -> s.split(" "));   // Stream<String[]>

// flatMap flattens to Stream<String>
sentences.stream()
    .flatMap(s -> Arrays.stream(s.split(" ")))
    .distinct()
    .sorted()
    .forEach(System.out::println);
// hello, java, streams, world

// Real-world: orders with multiple items
List<Order> orders = getOrders();

List<Item> allItems = orders.stream()
    .flatMap(order -> order.getItems().stream())  // Order → Stream<Item>
    .collect(Collectors.toList());

// Get all unique tags across all blog posts
Set<String> allTags = posts.stream()
    .flatMap(post -> post.getTags().stream())
    .collect(Collectors.toSet());

// Optional.stream() converts Optional to 0 or 1 element stream
// Super useful with flatMap to filter out empty Optionals:

List<String> ids = List.of("1", "bad", "3", "4");

List<Integer> validIds = ids.stream()
    .map(MyUtils::tryParseInt)      // returns Optional<Integer>
    .flatMap(Optional::stream)       // empty Optionals disappear, present ones unwrap
    .collect(Collectors.toList());
// [1, 3, 4] — "bad" silently dropped

// Helper method
static Optional<Integer> tryParseInt(String s) {
    try { return Optional.of(Integer.parseInt(s)); }
    catch (NumberFormatException e) { return Optional.empty(); }
}

List<Integer> bigList = /* 10 million integers */;

// Sequential — uses one thread
long count = bigList.stream()
    .filter(n -> n % 2 == 0)
    .count();

// Parallel — uses ForkJoinPool.commonPool() (all available CPU cores)
long count = bigList.parallelStream()
    .filter(n -> n % 2 == 0)
    .count();

// Or switch mid-pipeline
long count = bigList.stream()
    .parallel()
    .filter(n -> n % 2 == 0)
    .count();

// ❌ Race condition — shared mutable state
List<Integer> results = new ArrayList<>();  // NOT thread-safe
bigList.parallelStream().filter(n -> n > 0).forEach(results::add);  // data corruption!

// ✅ Use thread-safe collector instead
List<Integer> results = bigList.parallelStream()
    .filter(n -> n > 0)
    .collect(Collectors.toList());  // Collectors are designed for parallel use

// ❌ Order-sensitive operations with parallel (results non-deterministic)
bigList.parallelStream().findFirst();  // use findAny() with parallel — faster, no order guarantee
bigList.parallelStream().findAny();    // ✅ better for parallel

// 1. Use primitive streams to avoid boxing
intList.stream().mapToInt(Integer::intValue).sum();  // faster than .reduce(0, Integer::sum)

// 2. Filter early to reduce pipeline elements
stream.filter(expensive).map(cheap);   // ✅
stream.map(cheap).filter(expensive);   // ❌ applies map to more elements

// 3. Short-circuit for early exit
stream.filter(p).findFirst();   // stops at first match
stream.filter(p).anyMatch(q);   // stops as soon as any matches

// 4. Avoid sorted() on large streams when possible
// sorted() requires seeing all elements (O(n log n)) — use only when needed

// 5. Don't use parallel on small collections or I/O-bound tasks
// Rule of thumb: parallel pays off at 10k+ elements with CPU work