Pattern Matching in Java (16-21+)

// ❌ Before: verbose cast-after-check (Java 15 and earlier)
public String format(Object obj) {
    if (obj instanceof String) {
        String s = (String) obj;           // redundant cast
        return "String[" + s.length() + "]: " + s.toUpperCase();
    } else if (obj instanceof Integer) {
        Integer i = (Integer) obj;         // redundant cast
        return "Integer: " + i.intValue();
    } else if (obj instanceof List) {
        List<?> list = (List<?>) obj;      // redundant cast
        return "List[" + list.size() + "]";
    }
    return "Unknown";
}

// ✅ After: pattern variable bound in the check (Java 16+)
public String format(Object obj) {
    if (obj instanceof String s) {
        return "String[" + s.length() + "]: " + s.toUpperCase();
    } else if (obj instanceof Integer i) {
        return "Integer: " + i.intValue();
    } else if (obj instanceof List<?> list) {
        return "List[" + list.size() + "]";
    }
    return "Unknown";
}

// Pattern variable scope extends to where it's definitely matched
if (obj instanceof String s && s.length() > 5) {
    // s is in scope here — the && guarantees obj IS a String
    System.out.println(s.toUpperCase());
}

// ❌ COMPILE ERROR — || doesn't guarantee the match
if (obj instanceof String s || s.length() > 5) {  // ERROR: s might not exist
}

// Pattern variable in negation — scoped to else
if (!(obj instanceof String s)) {
    return;  // early exit
}
// s is in scope here! compiler knows obj IS a String
System.out.println(s.toUpperCase());

public String describe(Object obj) {
    return switch (obj) {
        case Integer i -> "Integer: " + i;
        case Long l    -> "Long: " + l;
        case Double d  -> "Double: " + d;
        case String s  -> "String: " + s;
        case null      -> "null!";
        default        -> "Other: " + obj.getClass().getSimpleName();
    };
}

sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double w, double h) implements Shape {}
record Triangle(double base, double h) implements Shape {}

// Compiler verifies ALL subtypes are covered — no default needed!
public double area(Shape shape) {
    return switch (shape) {
        case Circle c    -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.w() * r.h();
        case Triangle t  -> 0.5 * t.base() * t.h();
    };
}
// If you add a new Shape subtype later, this switch WON'T COMPILE until you handle it.

public String classifyNumber(Object obj) {
    return switch (obj) {
        case Integer i when i < 0    -> "Negative int: " + i;
        case Integer i when i == 0   -> "Zero";
        case Integer i when i <= 100 -> "Small positive: " + i;
        case Integer i               -> "Large positive: " + i;
        case Double d when d.isNaN() -> "Not a number";
        case Double d when d.isInfinite() -> "Infinity";
        case Double d                -> "Double: " + d;
        case null                    -> "null";
        default                      -> "Not a number type";
    };
}

record Point(int x, int y) {}
record Line(Point start, Point end) {}

// ❌ Before: manual extraction
public String describeLine(Object obj) {
    if (obj instanceof Line line) {
        Point start = line.start();
        Point end = line.end();
        int x1 = start.x();
        int y1 = start.y();
        int x2 = end.x();
        int y2 = end.y();
        return "Line from (" + x1 + "," + y1 + ") to (" + x2 + "," + y2 + ")";
    }
    return "Not a line";
}

// ✅ After: nested deconstruction in ONE pattern
public String describeLine(Object obj) {
    return switch (obj) {
        case Line(Point(int x1, int y1), Point(int x2, int y2))
            -> "Line from (" + x1 + "," + y1 + ") to (" + x2 + "," + y2 + ")";
        default -> "Not a line";
    };
}

record Address(String city, String country) {}
record Company(String name, Address hq) {}
record Employee(String name, Company company) {}

public String getEmployeeCity(Object obj) {
    return switch (obj) {
        // Three levels deep — record inside record inside record
        case Employee(String name, Company(_, Address(String city, String country)))
            when country.equals("US")
            -> name + " is based in " + city + ", USA";
        case Employee(String name, Company(String co, _))
            -> name + " works at " + co;
        default -> "Unknown";
    };
}

record Response(int status, String body, Map<String, String> headers) {}

public String summarize(Response resp) {
    return switch (resp) {
        case Response(int s, _, _) when s >= 500 -> "Server error: " + s;
        case Response(int s, _, _) when s >= 400 -> "Client error: " + s;
        case Response(int s, String body, _) when s == 200 -> "OK: " + body;
        case Response(_, _, _) -> "Other response";
    };
}

// Also works in instanceof
if (obj instanceof Line(Point(int x, _), _)) {
    // only care about the x coordinate of the start point
    System.out.println("Starts at x=" + x);
}

// Domain model — sealed hierarchy
public sealed interface PaymentEvent permits
    PaymentReceived, Refunded, Disputed, Settled {}

public record PaymentReceived(String txId, Money amount, Instant at) implements PaymentEvent {}
public record Refunded(String txId, Money amount, String reason) implements PaymentEvent {}
public record Disputed(String txId, String customerNote) implements PaymentEvent {}
public record Settled(String txId, Instant settledAt) implements PaymentEvent {}

// Handler — exhaustive, no default, compiler-checked
public Notification handle(PaymentEvent event) {
    return switch (event) {
        case PaymentReceived(String tx, Money amt, _)
            -> new Notification("Payment " + tx + " received: " + amt);
        case Refunded(String tx, Money amt, String reason)
            -> new Notification("Refund " + tx + ": " + amt + " — " + reason);
        case Disputed(String tx, String note)
            -> new Notification("Dispute on " + tx + ": " + note);
        case Settled(String tx, Instant at)
            -> new Notification("Settled " + tx + " at " + at);
    };
}
// Adding a new event type forces EVERY switch to be updated. Zero silent failures.

public String process(String input) {
    return switch (input) {
        case null           -> "No input provided";
        case String s when s.isBlank() -> "Empty input";
        case String s       -> "Processing: " + s;
    };
}

// Multiple null-aware patterns
public String describeShape(Shape shape) {
    return switch (shape) {
        case null            -> "No shape provided";
        case Circle c        -> "Circle r=" + c.radius();
        case Rectangle r     -> "Rect " + r.w() + "x" + r.h();
        case Triangle t      -> "Triangle b=" + t.base();
    };
}

// ✅ CORRECT — specific before general
return switch (obj) {
    case String s when s.isEmpty() -> "empty string";   // most specific
    case String s                  -> "string: " + s;   // less specific
    case Object o                  -> "other: " + o;    // least specific (dominates all)
};

// ❌ COMPILE ERROR — dominated pattern is unreachable
return switch (obj) {
    case String s                  -> "string: " + s;   // catches all strings
    case String s when s.isEmpty() -> "empty string";   // UNREACHABLE! dominated by above
    default -> "other";
};

// ❌ BEFORE: 45 lines, error-prone, no compiler safety
public String processEvent(Object event) {
    if (event == null) {
        return "No event";
    }
    if (event instanceof OrderPlaced) {
        OrderPlaced e = (OrderPlaced) event;
        if (e.total().compareTo(Money.of(1000)) > 0) {
            return "High-value order: " + e.orderId();
        }
        return "Order placed: " + e.orderId();
    } else if (event instanceof OrderShipped) {
        OrderShipped e = (OrderShipped) event;
        return "Shipped: " + e.orderId() + " tracking=" + e.trackingNumber();
    } else if (event instanceof OrderCancelled) {
        OrderCancelled e = (OrderCancelled) event;
        return "Cancelled: " + e.orderId() + " reason=" + e.reason();
    } else if (event instanceof OrderRefunded) {
        OrderRefunded e = (OrderRefunded) event;
        return "Refunded: " + e.orderId() + " amount=" + e.amount();
    } else {
        return "Unknown event: " + event.getClass().getName();
    }
}

// ✅ AFTER: 18 lines, exhaustive, null-safe, compiler-checked
public String processEvent(OrderEvent event) {
    return switch (event) {
        case null -> "No event";
        case OrderPlaced(String id, Money total, _) when total.compareTo(Money.of(1000)) > 0
            -> "High-value order: " + id;
        case OrderPlaced(String id, _, _)
            -> "Order placed: " + id;
        case OrderShipped(String id, String tracking)
            -> "Shipped: " + id + " tracking=" + tracking;
        case OrderCancelled(String id, String reason)
            -> "Cancelled: " + id + " reason=" + reason;
        case OrderRefunded(String id, Money amount)
            -> "Refunded: " + id + " amount=" + amount;
    };
}

public sealed interface DomainEvent permits
    UserRegistered, UserVerified, UserSuspended, UserDeleted {}

public record UserRegistered(UserId id, Email email, Instant at) implements DomainEvent {}
public record UserVerified(UserId id, Instant at) implements DomainEvent {}
public record UserSuspended(UserId id, String reason, Instant until) implements DomainEvent {}
public record UserDeleted(UserId id, Instant at) implements DomainEvent {}

public UserState apply(UserState state, DomainEvent event) {
    return switch (event) {
        case UserRegistered(UserId id, Email email, _)
            -> new UserState(id, email, Status.PENDING, null);
        case UserVerified(_, Instant at)
            -> state.withStatus(Status.ACTIVE).withVerifiedAt(at);
        case UserSuspended(_, String reason, Instant until)
            -> state.withStatus(Status.SUSPENDED).withSuspensionReason(reason);
        case UserDeleted _
            -> state.withStatus(Status.DELETED);
    };
}

public sealed interface JsonValue permits JsonString, JsonNumber, JsonBool, JsonNull, JsonArray, JsonObject {}
record JsonString(String value) implements JsonValue {}
record JsonNumber(double value) implements JsonValue {}
record JsonBool(boolean value) implements JsonValue {}
record JsonNull() implements JsonValue {}
record JsonArray(List<JsonValue> elements) implements JsonValue {}
record JsonObject(Map<String, JsonValue> fields) implements JsonValue {}

public String prettyPrint(JsonValue json, int indent) {
    String pad = " ".repeat(indent);
    return switch (json) {
        case JsonString(String v)  -> "\"" + v + "\"";
        case JsonNumber(double v)  -> String.valueOf(v);
        case JsonBool(boolean v)   -> String.valueOf(v);
        case JsonNull()            -> "null";
        case JsonArray(List<JsonValue> elems) ->
            "[\n" + elems.stream()
                .map(e -> pad + "  " + prettyPrint(e, indent + 2))
                .collect(Collectors.joining(",\n")) + "\n" + pad + "]";
        case JsonObject(Map<String, JsonValue> fields) ->
            "{\n" + fields.entrySet().stream()
                .map(e -> pad + "  \"" + e.getKey() + "\": " + prettyPrint(e.getValue(), indent + 2))
                .collect(Collectors.joining(",\n")) + "\n" + pad + "}";
    };
}

public sealed interface ValidationResult permits Valid, Invalid {}
record Valid() implements ValidationResult {}
record Invalid(List<String> errors) implements ValidationResult {}

public ValidationResult validate(CreateUserRequest req) {
    List<String> errors = new ArrayList<>();

    switch (req.email()) {
        case null -> errors.add("Email is required");
        case String e when !e.contains("@") -> errors.add("Invalid email format");
        case String e when e.length() > 255 -> errors.add("Email too long");
        case String _ -> {} // valid
    }

    switch (req.age()) {
        case Integer a when a < 0   -> errors.add("Age cannot be negative");
        case Integer a when a < 13  -> errors.add("Must be at least 13");
        case Integer a when a > 150 -> errors.add("Invalid age");
        case null                   -> errors.add("Age is required");
        case Integer _              -> {} // valid
    }

    return errors.isEmpty() ? new Valid() : new Invalid(errors);
}