Java 21+ Features (LTS)

// ❌ Old: 50+ lines of boilerplate
public class Point {
    private final int x;
    private final int y;
    public Point(int x, int y) { this.x = x; this.y = y; }
    public int x() { return x; }
    public int y() { return y; }
    @Override public boolean equals(Object o) { ... }
    @Override public int hashCode() { ... }
    @Override public String toString() { ... }
}

// ✅ New: ONE line — gets constructor, accessors, equals, hashCode, toString
public record Point(int x, int y) {}

public record Email(String value) {
    // Compact constructor — validates before assignment
    public Email {
        if (value == null || !value.contains("@")) {
            throw new IllegalArgumentException("Invalid email: " + value);
        }
        value = value.toLowerCase().trim();  // can transform
    }
}

// Usage
Email email = new Email("User@Example.COM");
System.out.println(email.value());  // "user@example.com"

// Perfect for request/response DTOs
public record CreateOrderRequest(
    @NotBlank String customerId,
    @NotEmpty List<@Valid OrderItem> items,
    @NotNull Address shippingAddress
) {}

public record OrderItem(
    @NotBlank String sku,
    @Positive int quantity,
    @PositiveOrZero BigDecimal unitPrice
) {}

// Spring auto-deserializes JSON to records!
@PostMapping("/orders")
public OrderResponse createOrder(@Valid @RequestBody CreateOrderRequest request) {
    // request.customerId(), request.items() — accessor methods, no getters
}

// Only these three classes can implement Shape
public sealed interface Shape permits Circle, Rectangle, Triangle {}

public record Circle(double radius) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}
public record Triangle(double base, double height) implements Shape {}

// Compiler KNOWS all possible subtypes → exhaustive switch!
public double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        case Triangle t -> 0.5 * t.base() * t.height();
        // No default needed — compiler verifies all cases covered!
    };
}

public sealed interface OrderEvent permits
    OrderPlaced, OrderConfirmed, OrderShipped, OrderCancelled {}

public record OrderPlaced(String orderId, Instant placedAt, Money total) implements OrderEvent {}
public record OrderConfirmed(String orderId, Instant confirmedAt) implements OrderEvent {}
public record OrderShipped(String orderId, String trackingNumber) implements OrderEvent {}
public record OrderCancelled(String orderId, String reason) implements OrderEvent {}

// Event handler — compile-time guarantee you handle ALL events
public void handle(OrderEvent event) {
    switch (event) {
        case OrderPlaced e -> notifyWarehouse(e);
        case OrderConfirmed e -> chargePayment(e);
        case OrderShipped e -> notifyCustomer(e);
        case OrderCancelled e -> processRefund(e);
    }
}

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

// ✅ New: binding variable in the check
if (obj instanceof String s) {
    System.out.println(s.length());  // s is already cast and scoped
}

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

// Pattern matching + guards in switch
public String describe(Object obj) {
    return switch (obj) {
        case Integer i when i > 0 -> "Positive integer: " + i;
        case Integer i when i < 0 -> "Negative integer: " + i;
        case Integer i -> "Zero";
        case String s when s.isBlank() -> "Empty string";
        case String s -> "String of length " + s.length();
        case List<?> list when list.isEmpty() -> "Empty list";
        case List<?> list -> "List with " + list.size() + " elements";
        case null -> "null value";
        default -> "Unknown: " + obj.getClass().getSimpleName();
    };
}

// Destructure records directly in patterns
public record Address(String city, String country) {}
public record Customer(String name, Address address) {}

public String greet(Object obj) {
    return switch (obj) {
        // Nested destructuring!
        case Customer(String name, Address(String city, String country))
            when country.equals("US") -> "Hey " + name + " from " + city + "!";
        case Customer(String name, _) -> "Hello " + name + "!";
        default -> "Hi there!";
    };
}

// ❌ Before: inconsistent APIs
List<String> list = List.of("a", "b", "c");
list.get(0);                    // first
list.get(list.size() - 1);     // last (ugly!)

Deque<String> deque = new ArrayDeque<>(list);
deque.getFirst();               // first
deque.getLast();                 // last (different API!)

SortedSet<String> sorted = new TreeSet<>(list);
sorted.first();                 // first (yet another API!)
sorted.last();                  // last

// ✅ After: unified SequencedCollection interface
SequencedCollection<String> seq = list;
seq.getFirst();     // "a"
seq.getLast();      // "c"
seq.reversed();     // reversed view: ["c", "b", "a"]

// When you don't need the variable
try {
    parseJson(input);
} catch (JsonException _) {  // don't need the exception
    return defaultValue;
}

list.stream()
    .map(_ -> generateId())  // don't need the element
    .toList();

// In enhanced for
for (var _ : collection) {
    count++;  // just counting, don't need elements
}

// Before: HelloWorld.java needs a class wrapper
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello!");
    }
}

// After: just write code (great for learning/scripting)
void main() {
    System.out.println("Hello!");
}