List<Employee> result = employees.stream()
    .filter(e -> e.getSalary() > 50000)
    .sorted(Comparator.comparing(Employee::getName))
    .collect(Collectors.toList());

// Key points:
// - filter() is an intermediate operation (lazy)
// - sorted() is a stateful intermediate operation
// - collect() is the terminal operation that triggers execution
// - Comparator.comparing() with method reference is cleaner than lambda

Optional<Integer> secondHighest = salaries.stream()
    .distinct()                          // Remove duplicates
    .sorted(Comparator.reverseOrder())   // Sort descending
    .skip(1)                             // Skip the highest
    .findFirst();                        // Get the second

// Handle the Optional properly
secondHighest.ifPresentOrElse(
    salary -> System.out.println("Second highest: " + salary),
    () -> System.out.println("No second highest found")
);

Map<String, Long> countByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.counting()
    ));

// More complex: group by department, get average salary
Map<String, Double> avgSalaryByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.averagingDouble(Employee::getSalary)
    ));

// Before Java 8: Anonymous inner class
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

// Java 8: Lambda expression
Runnable r2 = () -> System.out.println("Hello");

// Key differences:
// 1. Lambda does NOT create a new class file (.class)
// 2. Lambda uses invokedynamic bytecode (more efficient)
// 3. 'this' in lambda refers to enclosing class, not the lambda itself
// 4. Lambda can only implement functional interfaces (single abstract method)

// 1. Static method reference
Function<String, Integer> parser = Integer::parseInt;

// 2. Instance method of a particular object
String str = "hello";
Supplier<String> upper = str::toUpperCase;

// 3. Instance method of an arbitrary object of a type
Function<String, String> toUpper = String::toUpperCase;

// 4. Constructor reference
Supplier<ArrayList<String>> listFactory = ArrayList::new;

// When to use: method reference is preferred when the lambda
// simply calls an existing method with the same parameters
// Lambda: (s) -> s.toUpperCase()  →  Method ref: String::toUpperCase

// Predicate<T> — takes T, returns boolean (used in filter)
Predicate<String> isLong = s -> s.length() > 10;
list.stream().filter(isLong).collect(Collectors.toList());

// Function<T, R> — takes T, returns R (used in map)
Function<String, Integer> length = String::length;
list.stream().map(length).collect(Collectors.toList());

// Consumer<T> — takes T, returns void (used in forEach)
Consumer<String> printer = System.out::println;
list.forEach(printer);

// Supplier<T> — takes nothing, returns T (used in factory patterns)
Supplier<List<String>> listMaker = ArrayList::new;
List<String> newList = listMaker.get();

// BiFunction, BiPredicate, UnaryOperator, BinaryOperator
// are variations — know they exist, explain if asked

@FunctionalInterface
interface StringProcessor {
    String process(String input);

    // Default methods are allowed
    default StringProcessor andThen(StringProcessor after) {
        return input -> after.process(this.process(input));
    }
}

// Usage with lambda
StringProcessor trimmer = String::trim;
StringProcessor upper = String::toUpperCase;
StringProcessor pipeline = trimmer.andThen(upper);

String result = pipeline.process("  hello world  ");
// Result: "HELLO WORLD"

// Bad: returns null, caller might forget to check
public Employee findById(int id) {
    return employeeMap.get(id); // Could be null!
}

// Good: returns Optional, forces caller to handle absence
public Optional<Employee> findById(int id) {
    return Optional.ofNullable(employeeMap.get(id));
}

// Using Optional properly
findById(1)
    .map(Employee::getName)
    .orElse("Unknown Employee");

// NEVER do this — defeats the purpose of Optional
if (optional.isPresent()) {
    return optional.get(); // This is just null-checking with extra steps
}

// Old API problems:
Date date = new Date();       // Mutable — anyone can change it
date.setTime(0);              // Not thread-safe
int month = date.getMonth();  // Returns 0 for January (confusing!)

// New API (java.time package):
LocalDate today = LocalDate.now();           // Date only, no time
LocalDateTime now = LocalDateTime.now();     // Date + time, no timezone
ZonedDateTime zoned = ZonedDateTime.now();   // Date + time + timezone

// Immutable — every operation returns a new object
LocalDate tomorrow = today.plusDays(1);      // today is unchanged
LocalDate nextMonth = today.plusMonths(1);

// Thread-safe by design (immutable objects are always thread-safe)
// Clear API: Month.JANUARY, not 0