Modern Java (Java 8-21+)

// 50+ lines of boilerplate for a simple data class
public final class User {
    private final String id;
    private final String name;
    private final String email;

    public User(String id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public String getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) &&
               Objects.equals(name, user.name) &&
               Objects.equals(email, user.email);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, email);
    }

    @Override
    public String toString() {
        return "User[id=" + id + ", name=" + name + ", email=" + email + "]";
    }
}

// Old way: instanceof + cast
if (obj instanceof String) {
    String s = (String) obj;  // Redundant cast
    System.out.println(s.length());
}

// New way: pattern matching for instanceof (Java 16+)
if (obj instanceof String s) {
    System.out.println(s.length());  // s already typed!
}

// Can use in conditions
if (obj instanceof String s && s.length() > 5) {
    System.out.println("Long string: " + s);
}

// Guards with &&
if (obj instanceof Integer i && i > 0) {
    System.out.println("Positive: " + i);
}

// Control exactly which classes can extend/implement
// Compiler knows ALL possible subtypes

public sealed interface Shape
    permits Circle, Rectangle, Triangle {
    double area();
}

public record Circle(double radius) implements Shape {
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public record Rectangle(double width, double height) implements Shape {
    @Override
    public double area() {
        return width * height;
    }
}

public record Triangle(double base, double height) implements Shape {
    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

// Exhaustive switch - compiler knows all cases!
String describe(Shape shape) {
    return switch (shape) {
        case Circle c -> "Circle with radius " + c.radius();
        case Rectangle r -> "Rectangle " + r.width() + "x" + r.height();
        case Triangle t -> "Triangle with base " + t.base();
        // No default needed! Compiler knows these are ALL cases
    };
}

// If you add a new Shape subtype, ALL switches must be updated
// This is caught at COMPILE TIME, not runtime!

// Traditional threads: expensive, limited (thousands)
for (int i = 0; i < 10000; i++) {
    new Thread(() -> doWork()).start();  // May exhaust OS threads
}

// Virtual threads: cheap, unlimited (millions!)
for (int i = 0; i < 1_000_000; i++) {
    Thread.startVirtualThread(() -> doWork());  // No problem!
}

// Using ExecutorService
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> {
            // Each task gets its own virtual thread
            String result = fetchFromApi();  // Blocking IO is fine!
            processResult(result);
        });
    }
}  // Waits for all tasks

// Why this matters:
// - Write simple blocking code (like Python)
// - Get async performance automatically
// - No callback hell, no reactive complexity
// - One virtual thread per request at Twilio scale = trivial

// Spring Boot 3.2+ supports virtual threads out of the box
// spring.threads.virtual.enabled=true

// Old NPE (before Java 14)
// Exception in thread "main" java.lang.NullPointerException
//     at Example.main(Example.java:15)
// Which part was null?!

// New NPE (Java 14+)
// Exception in thread "main" java.lang.NullPointerException:
//     Cannot invoke "String.toUpperCase()" because the return value
//     of "User.getName()" is null

String city = user.getAddress().getCity().toUpperCase();
// Now tells you EXACTLY which part was null:
// - user was null?
// - getAddress() returned null?
// - getCity() returned null?

// toList() instead of collect(Collectors.toList()) - Java 16+
List<String> names = users.stream()
    .map(User::getName)
    .toList();  // Returns immutable list

// mapMulti() - flatMap alternative (Java 16+)
List<Integer> numbers = Stream.of(1, 2, 3)
    .<Integer>mapMulti((n, consumer) -> {
        consumer.accept(n);
        consumer.accept(n * 10);
    })
    .toList();  // [1, 10, 2, 20, 3, 30]

// takeWhile/dropWhile (Java 9+)
List<Integer> nums = List.of(1, 2, 3, 4, 5);
nums.stream()
    .takeWhile(n -> n < 4)
    .toList();  // [1, 2, 3]

nums.stream()
    .dropWhile(n -> n < 4)
    .toList();  // [4, 5]

// Collectors.teeing() - two collectors at once (Java 12+)
var result = Stream.of(1, 2, 3, 4, 5).collect(
    Collectors.teeing(
        Collectors.summingInt(Integer::intValue),  // sum
        Collectors.counting(),                      // count
        (sum, count) -> sum / count                 // average
    )
);  // 3