Pattern matching for instanceof is a powerful feature introduced in Java 16 (as a preview in Java 14) that simplifies type checking and casting, making code more readable and less error-prone.

1. Basic Pattern Matching with instanceof

Traditional vs Pattern Matching Approach

public class BasicPatternMatching { public static void main(String[] args) { demonstrateBasicPatternMatching(); demonstrateWithCollections(); demonstrateNullSafety(); } public static void demonstrateBasicPatternMatching() { System.out.println("=== Basic Pattern Matching ==="); Object obj = "Hello, Pattern Matching!"; // ❌ Traditional approach (verbose) if (obj instanceof String) { String str = (String) obj; System.out.println("Traditional: " + str.toUpperCase()); } // ✅ Pattern matching approach (concise) if (obj instanceof String str) { System.out.println("Pattern Matching: " + str.toUpperCase()); } // More examples with different types Object number = 42; Object list = List.of(1, 2, 3); processObject(number); processObject(list); processObject("Test String"); } public static void processObject(Object obj) { System.out.println("\nProcessing object: " + obj); if (obj instanceof Integer i) { System.out.println("It's an integer: " + (i * 2)); } else if (obj instanceof String s) { System.out.println("It's a string: " + s.length() + " characters"); } else if (obj instanceof List<?> list) { System.out.println("It's a list with " + list.size() + " elements"); } else { System.out.println("Unknown type: " + obj.getClass().getSimpleName()); } } public static void demonstrateWithCollections() { System.out.println("\n=== Pattern Matching with Collections ==="); List<Object> mixedList = List.of( "String value", 42, 3.14, List.of("a", "b", "c"), new StringBuilder("builder") ); for (Object item : mixedList) { // Pattern matching in for-each loop if (item instanceof String s) { System.out.println("String: " + s.toUpperCase()); } else if (item instanceof Integer i) { System.out.println("Integer: " + (i + 10)); } else if (item instanceof Double d) { System.out.println("Double: " + (d * 2)); } else if (item instanceof List<?> sublist) { System.out.println("List: " + sublist); } else { System.out.println("Other: " + item); } } } public static void demonstrateNullSafety() { System.out.println("\n=== Null Safety with Pattern Matching ==="); Object possiblyNull = Math.random() > 0.5 ? "I'm not null" : null; // Pattern matching safely handles null if (possiblyNull instanceof String s) { System.out.println("Not null string: " + s); } else { System.out.println("Object is null or not a String"); } // Traditional approach would need explicit null check if (possiblyNull != null && possiblyNull instanceof String) { String s = (String) possiblyNull; System.out.println("Traditional: " + s); } } }

2. Advanced Pattern Matching Features

Pattern Variables and Scope

public class AdvancedPatternMatching { public static void main(String[] args) { demonstratePatternVariableScope(); demonstrateComplexConditions(); demonstrateNestedPatterns(); } public static void demonstratePatternVariableScope() { System.out.println("=== Pattern Variable Scope ==="); Object obj = "Scope Demonstration"; // Pattern variable 's' is only in scope within the if block if (obj instanceof String s) { System.out.println("Inside if block: " + s.toUpperCase()); // 's' is available here } // 's' is not available here - compilation error // System.out.println(s); // Pattern variable with logical operators if (obj instanceof String s && s.length() > 5) { System.out.println("Long string: " + s); } // This works because s is in scope for the entire && expression if (obj instanceof String s && !s.isEmpty()) { System.out.println("Non-empty string: " + s); } // This doesn't work - s is not in scope for the || expression // if (obj instanceof String s || s.length() > 0) { } // Compilation error } public static void demonstrateComplexConditions() { System.out.println("\n=== Complex Conditions ==="); Object[] objects = { "Hello", 100, "", " ", null, "Another string" }; for (Object obj : objects) { // Complex condition with pattern matching if (obj instanceof String s && s != null && !s.trim().isEmpty()) { System.out.println("Valid non-empty string: '" + s + "'"); } else if (obj instanceof String s && (s == null || s.trim().isEmpty())) { System.out.println("Invalid or empty string: " + (s == null ? "null" : "'" + s + "'")); } else if (obj instanceof Integer i) { System.out.println("Integer: " + i); } else { System.out.println("Other type: " + (obj == null ? "null" : obj.getClass().getSimpleName())); } } } public static void demonstrateNestedPatterns() { System.out.println("\n=== Nested Patterns ==="); // Simulating complex object structures Object complexObj = Map.of( "user", Map.of("name", "John", "age", 30), "settings", List.of("dark-mode", "notifications") ); // Nested pattern matching if (complexObj instanceof Map<?, ?> map && map.get("user") instanceof Map<?, ?> userMap && userMap.get("name") instanceof String userName) { System.out.println("User name: " + userName); } // Processing nested collections Object nestedData = List.of( List.of(1, 2, 3), "String item", Map.of("key", "value") ); if (nestedData instanceof List<?> list) { for (Object item : list) { if (item instanceof List<?> innerList) { System.out.println("Nested list: " + innerList); } else if (item instanceof String s) { System.out.println("String item: " + s); } else if (item instanceof Map<?, ?> map) { System.out.println("Map item: " + map); } } } } // Method with return values using pattern matching public static String processWithReturn(Object obj) { // Using pattern matching in return scenarios if (obj instanceof String s) { return "String: " + s.toUpperCase(); } else if (obj instanceof Integer i) { return "Integer squared: " + (i * i); } else if (obj instanceof List<?> list && !list.isEmpty()) { return "Non-empty list with " + list.size() + " elements"; } else { return "Unknown type: " + (obj == null ? "null" : obj.getClass().getSimpleName()); } } }

3. Real-World Use Cases

Data Processing and Validation

import java.util.*; import java.time.*; public class RealWorldPatternMatching { public static void main(String[] args) { demonstrateDataValidation(); demonstrateAPIParsing(); demonstrateEventProcessing(); } public static void demonstrateDataValidation() { System.out.println("=== Data Validation with Pattern Matching ==="); List<Object> userInputs = Arrays.asList( "[email protected]", "invalid-email", 25, -5, LocalDate.of(1990, 1, 1), LocalDate.of(2025, 1, 1) // Future date ); for (Object input : userInputs) { ValidationResult result = validateUserInput(input); System.out.println("Input: " + input + " -> " + result); } } public static ValidationResult validateUserInput(Object input) { // Email validation if (input instanceof String s && isValidEmail(s)) { return ValidationResult.valid("Email"); } // Age validation else if (input instanceof Integer age) { if (age >= 0 && age <= 150) { return ValidationResult.valid("Age: " + age); } else { return ValidationResult.invalid("Age must be between 0 and 150"); } } // Date validation else if (input instanceof LocalDate date) { if (!date.isAfter(LocalDate.now())) { return ValidationResult.valid("Date: " + date); } else { return ValidationResult.invalid("Date cannot be in the future"); } } // Invalid type else { return ValidationResult.invalid("Unsupported input type"); } } private static boolean isValidEmail(String email) { return email != null && email.contains("@") && email.contains("."); } static class ValidationResult { private final boolean valid; private final String message; private ValidationResult(boolean valid, String message) { this.valid = valid; this.message = message; } public static ValidationResult valid(String message) { return new ValidationResult(true, message); } public static ValidationResult invalid(String message) { return new ValidationResult(false, message); } @Override public String toString() { return (valid ? "VALID" : "INVALID") + ": " + message; } } public static void demonstrateAPIParsing() { System.out.println("\n=== API Response Parsing ==="); // Simulating different API responses Object[] apiResponses = { Map.of("status", "success", "data", Map.of("user", "John")), Map.of("status", "error", "message", "Invalid request"), "Unexpected response type", 404, null }; for (Object response : apiResponses) { processAPIResponse(response); } } public static void processAPIResponse(Object response) { System.out.println("\nProcessing API response: " + response); if (response instanceof Map<?, ?> map) { // Success response if (map.get("status") instanceof String status && "success".equals(status)) { if (map.get("data") instanceof Map<?, ?> data) { System.out.println("Success! Data: " + data); } else { System.out.println("Success but no data"); } } // Error response else if (map.get("status") instanceof String status && "error".equals(status)) { if (map.get("message") instanceof String message) { System.out.println("Error: " + message); } else { System.out.println("Error but no message"); } } // Unknown status else { System.out.println("Unknown response status"); } } // HTTP status code else if (response instanceof Integer code) { if (code >= 200 && code < 300) { System.out.println("HTTP Success: " + code); } else if (code >= 400 && code < 500) { System.out.println("HTTP Client Error: " + code); } else if (code >= 500) { System.out.println("HTTP Server Error: " + code); } else { System.out.println("HTTP Other: " + code); } } // Unexpected response type else if (response instanceof String s) { System.out.println("Unexpected string response: " + s); } // Null response else if (response == null) { System.out.println("Null response received"); } // Other types else { System.out.println("Unknown response type: " + response.getClass().getSimpleName()); } } public static void demonstrateEventProcessing() { System.out.println("\n=== Event Processing ==="); List<Object> events = Arrays.asList( new UserLoginEvent("john_doe", LocalDateTime.now()), new PaymentEvent(100.50, "USD", "order_123"), new SystemAlertEvent("HIGH", "CPU usage at 95%"), "Invalid event string", 12345 ); for (Object event : events) { processEvent(event); } } public static void processEvent(Object event) { if (event instanceof UserLoginEvent login && login.getUsername() != null) { System.out.println("User login: " + login.getUsername() + " at " + login.getTimestamp()); } else if (event instanceof PaymentEvent payment) { System.out.printf("Payment: %s %.2f for %s%n", payment.getCurrency(), payment.getAmount(), payment.getOrderId()); } else if (event instanceof SystemAlertEvent alert && "HIGH".equals(alert.getSeverity())) { System.out.println("HIGH ALERT: " + alert.getMessage()); } else if (event instanceof String s) { System.out.println("Unexpected string event: " + s); } else { System.out.println("Unknown event type: " + (event == null ? "null" : event.getClass().getSimpleName())); } } } // Event classes for demonstration class UserLoginEvent { private final String username; private final LocalDateTime timestamp; public UserLoginEvent(String username, LocalDateTime timestamp) { this.username = username; this.timestamp = timestamp; } public String getUsername() { return username; } public LocalDateTime getTimestamp() { return timestamp; } } class PaymentEvent { private final double amount; private final String currency; private final String orderId; public PaymentEvent(double amount, String currency, String orderId) { this.amount = amount; this.currency = currency; this.orderId = orderId; } public double getAmount() { return amount; } public String getCurrency() { return currency; } public String getOrderId() { return orderId; } } class SystemAlertEvent { private final String severity; private final String message; public SystemAlertEvent(String severity, String message) { this.severity = severity; this.message = message; } public String getSeverity() { return severity; } public String getMessage() { return message; } }

4. Pattern Matching with Records and Sealed Classes

Records and Pattern Matching

public class RecordPatternMatching { public static void main(String[] args) { demonstrateRecordPatterns(); demonstrateSealedHierarchy(); } // Record definitions record Point(int x, int y) {} record Circle(Point center, double radius) {} record Rectangle(Point topLeft, Point bottomRight) {} public static void demonstrateRecordPatterns() { System.out.println("=== Pattern Matching with Records ==="); Object[] shapes = { new Point(10, 20), new Circle(new Point(5, 5), 10.0), new Rectangle(new Point(0, 0), new Point(10, 10)), "Not a shape" }; for (Object shape : shapes) { double area = calculateArea(shape); System.out.println("Shape: " + shape + " -> Area: " + area); } } public static double calculateArea(Object shape) { // Pattern matching with records (Java 19+ preview) if (shape instanceof Point p) { return 0; // Point has no area } else if (shape instanceof Circle c) { return Math.PI * c.radius() * c.radius(); } else if (shape instanceof Rectangle r) { int width = Math.abs(r.bottomRight().x() - r.topLeft().x()); int height = Math.abs(r.bottomRight().y() - r.topLeft().y()); return width * height; } else { return -1; // Unknown shape } } // Enhanced pattern matching with record decomposition (Java 21+ preview) public static void processShape(Object shape) { // Record patterns - decomposing records in patterns if (shape instanceof Point(int x, int y)) { System.out.println("Point at (" + x + ", " + y + ")"); } else if (shape instanceof Circle(Point center, double radius)) { System.out.println("Circle with center " + center + " and radius " + radius); } else if (shape instanceof Rectangle(Point tl, Point br)) { System.out.println("Rectangle from " + tl + " to " + br); } } } // Sealed classes for exhaustive pattern matching sealed interface Shape permits CircleShape, RectangleShape, TriangleShape { double area(); } record CircleShape(double radius) implements Shape { @Override public double area() { return Math.PI * radius * radius; } } record RectangleShape(double width, double height) implements Shape { @Override public double area() { return width * height; } } record TriangleShape(double base, double height) implements Shape { @Override public double area() { return 0.5 * base * height; } } class SealedPatternMatching { public static void demonstrateSealedHierarchy() { System.out.println("\n=== Sealed Classes and Exhaustive Pattern Matching ==="); Shape[] shapes = { new CircleShape(5.0), new RectangleShape(4.0, 6.0), new TriangleShape(3.0, 4.0) }; for (Shape shape : shapes) { describeShape(shape); } } public static void describeShape(Shape shape) { // Exhaustive pattern matching with sealed classes // The compiler knows all possible implementations String description = switch (shape) { case CircleShape c -> "Circle with radius " + c.radius() + " and area " + c.area(); case RectangleShape r -> "Rectangle " + r.width() + "x" + r.height() + " with area " + r.area(); case TriangleShape t -> "Triangle base " + t.base() + " height " + t.height() + " with area " + t.area(); // No default needed - all permitted types are covered }; System.out.println(description); } // Pattern matching in instanceof with sealed classes public static void processShape(Shape shape) { if (shape instanceof CircleShape c) { System.out.println("Processing circle: " + c.radius()); } else if (shape instanceof RectangleShape r) { System.out.println("Processing rectangle: " + r.width() + "x" + r.height()); } else if (shape instanceof TriangleShape t) { System.out.println("Processing triangle: " + t.base() + "x" + t.height()); } } }

5. Switch Expressions with Pattern Matching

Pattern Matching in Switch (Java 21+)

public class SwitchPatternMatching { public static void main(String[] args) { demonstrateSwitchPatterns(); demonstrateGuardedPatterns(); demonstrateNullHandling(); } public static void demonstrateSwitchPatterns() { System.out.println("=== Pattern Matching in Switch ==="); Object[] objects = { "Hello World", 42, 3.14, List.of(1, 2, 3), new int[]{1, 2, 3}, null, 'A' }; for (Object obj : objects) { String result = describeObject(obj); System.out.println(obj + " -> " + result); } } public static String describeObject(Object obj) { return switch (obj) { case String s -> "String: \"" + s + "\" with length " + s.length(); case Integer i -> "Integer: " + i + " (squared: " + (i * i) + ")"; case Double d -> "Double: " + d + " (formatted: " + String.format("%.2f", d) + ")"; case List<?> list -> "List with " + list.size() + " elements: " + list; case int[] array -> "int array with " + array.length + " elements"; case null -> "Null object"; default -> "Unknown type: " + obj.getClass().getSimpleName(); }; } public static void demonstrateGuardedPatterns() { System.out.println("\n=== Guarded Patterns ==="); Object[] numbers = {10, -5, 0, 100, -1, 50}; for (Object number : numbers) { String category = categorizeNumber(number); System.out.println(number + " -> " + category); } } public static String categorizeNumber(Object number) { return switch (number) { case Integer i when i > 0 -> "Positive integer: " + i; case Integer i when i < 0 -> "Negative integer: " + i; case Integer i -> "Zero"; case Double d when d > 0 -> "Positive double: " + d; case Double d when d < 0 -> "Negative double: " + d; case Double d -> "Zero double"; case null -> "Null number"; default -> "Not a number: " + number.getClass().getSimpleName(); }; } public static void demonstrateNullHandling() { System.out.println("\n=== Null Handling in Switch ==="); Object[] possiblyNull = {"Hello", null, "World", null, "!"}; for (Object obj : possiblyNull) { String result = handlePossiblyNull(obj); System.out.println(obj + " -> " + result); } } public static String handlePossiblyNull(Object obj) { return switch (obj) { case null -> "Handling null case explicitly"; case String s when s.length() > 5 -> "Long string: " + s; case String s -> "Short string: " + s; default -> "Other: " + obj; }; } // Complex example with multiple patterns public static String processComplexObject(Object obj) { return switch (obj) { case String s when s.isEmpty() -> "Empty string"; case String s when s.length() == 1 -> "Single character: " + s; case String s -> "String: " + s; case Integer i when i == 0 -> "Zero"; case Integer i when i > 0 && i < 100 -> "Small positive integer"; case Integer i when i >= 100 -> "Large positive integer"; case Integer i -> "Negative integer"; case List<?> list when list.isEmpty() -> "Empty list"; case List<?> list when list.size() == 1 -> "Single element list"; case List<?> list -> "List with " + list.size() + " elements"; case Map<?, ?> map when map.isEmpty() -> "Empty map"; case Map<?, ?> map -> "Map with " + map.size() + " entries"; case null -> "Null object"; default -> "Unhandled type: " + obj.getClass().getSimpleName(); }; } }

6. Performance Considerations

Benchmarking Pattern Matching

import java.util.*; public class PatternMatchingPerformance { public static void main(String[] args) { demonstratePerformanceComparison(); } public static void demonstratePerformanceComparison() { System.out.println("=== Pattern Matching Performance ==="); List<Object> testData = generateTestData(10000); // Warm up for (int i = 0; i < 1000; i++) { traditionalApproach(testData.get(i % testData.size())); patternMatchingApproach(testData.get(i % testData.size())); } // Benchmark traditional approach long traditionalStart = System.nanoTime(); for (Object obj : testData) { traditionalApproach(obj); } long traditionalTime = System.nanoTime() - traditionalStart; // Benchmark pattern matching approach long patternStart = System.nanoTime(); for (Object obj : testData) { patternMatchingApproach(obj); } long patternTime = System.nanoTime() - patternStart; System.out.printf("Traditional approach: %,d ns%n", traditionalTime); System.out.printf("Pattern matching: %,d ns%n", patternTime); System.out.printf("Difference: %.2f%%%n", ((double) patternTime / traditionalTime - 1) * 100); } public static String traditionalApproach(Object obj) { if (obj instanceof String) { String s = (String) obj; return s.toUpperCase(); } else if (obj instanceof Integer) { Integer i = (Integer) obj; return String.valueOf(i * 2); } else if (obj instanceof List) { List<?> list = (List<?>) obj; return "List size: " + list.size(); } else { return "Unknown"; } } public static String patternMatchingApproach(Object obj) { if (obj instanceof String s) { return s.toUpperCase(); } else if (obj instanceof Integer i) { return String.valueOf(i * 2); } else if (obj instanceof List<?> list) { return "List size: " + list.size(); } else { return "Unknown"; } } private static List<Object> generateTestData(int size) { List<Object> data = new ArrayList<>(); Random random = new Random(); for (int i = 0; i < size; i++) { int type = random.nextInt(4); switch (type) { case 0 -> data.add("String_" + i); case 1 -> data.add(i); case 2 -> data.add(List.of(i, i+1, i+2)); case 3 -> data.add((double) i); } } return data; } // Performance tips public static void showPerformanceTips() { System.out.println("\n=== Performance Tips ==="); System.out.println(""" 1. Pattern matching has similar performance to traditional approach 2. The JVM can optimize both approaches effectively 3. Focus on readability rather than micro-optimizations 4. Complex patterns with guards may have slight overhead 5. Use the most specific pattern first for better performance """); } }

7. Best Practices and Common Pitfalls

Pattern Matching Best Practices

import java.util.*; public class PatternMatchingBestPractices { public static void main(String[] args) { demonstrateBestPractices(); demonstrateCommonPitfalls(); demonstrateRefactoringExamples(); } public static void demonstrateBestPractices() { System.out.println("=== Best Practices ==="); Object obj = "Best Practices Example"; // ✅ GOOD: Simple and readable if (obj instanceof String s) { System.out.println("String: " + s); } // ✅ GOOD: Combine with other conditions if (obj instanceof String s && s.length() > 10) { System.out.println("Long string: " + s); } // ✅ GOOD: Use in switch expressions for exhaustive handling String result = switch (obj) { case String s -> "String: " + s; case Integer i -> "Integer: " + i; case null -> "Null"; default -> "Other"; }; System.out.println("Switch result: " + result); } public static void demonstrateCommonPitfalls() { System.out.println("\n=== Common Pitfalls ==="); Object obj = "Test"; // ❌ BAD: Unnecessary pattern variable if (obj instanceof String s) { System.out.println(s.toUpperCase()); // s is used } // ✅ GOOD: Use traditional instanceof if you don't need the variable if (obj instanceof String) { System.out.println("It's a string"); } // ❌ BAD: Pattern variable scope misunderstanding // if (obj instanceof String s || s.length() > 0) { } // Compilation error // ✅ GOOD: Understand pattern variable scope if (obj instanceof String s && s.length() > 0) { System.out.println("Valid string: " + s); } // ❌ BAD: Overly complex patterns Object complex = Map.of("data", List.of(1, 2, 3)); if (complex instanceof Map<?, ?> map && map.get("data") instanceof List<?> list && list.size() > 0 && list.get(0) instanceof Integer first) { System.out.println("First element: " + first); } // ✅ GOOD: Consider extracting complex logic processComplexObject(complex); } private static void processComplexObject(Object obj) { if (obj instanceof Map<?, ?> map) { Object data = map.get("data"); if (data instanceof List<?> list && !list.isEmpty()) { Object first = list.get(0); if (first instanceof Integer i) { System.out.println("First element: " + i); } } } } public static void demonstrateRefactoringExamples() { System.out.println("\n=== Refactoring Examples ==="); // Before refactoring - traditional approach Object traditionalObj = "Hello"; String traditionalResult; if (traditionalObj instanceof String) { String s = (String) traditionalObj; traditionalResult = s.toUpperCase(); } else if (traditionalObj instanceof Integer) { Integer i = (Integer) traditionalObj; traditionalResult = String.valueOf(i * 2); } else { traditionalResult = "Unknown"; } System.out.println("Traditional: " + traditionalResult); // After refactoring - pattern matching Object patternObj = "Hello"; String patternResult = switch (patternObj) { case String s -> s.toUpperCase(); case Integer i -> String.valueOf(i * 2); default -> "Unknown"; }; System.out.println("Pattern matching: " + patternResult); // Complex refactoring example processUserInputRefactored("[email protected]"); processUserInputRefactored(25); processUserInputRefactored(null); } // Before refactoring public static void processUserInputTraditional(Object input) { if (input instanceof String) { String s = (String) input; if (s.contains("@")) { System.out.println("Email: " + s); } else { System.out.println("Username: " + s); } } else if (input instanceof Integer) { Integer i = (Integer) input; if (i >= 0) { System.out.println("Age: " + i); } else { System.out.println("Invalid age"); } } else if (input == null) { System.out.println("Null input"); } } // After refactoring with pattern matching public static void processUserInputRefactored(Object input) { switch (input) { case String s when s.contains("@") -> System.out.println("Email: " + s); case String s -> System.out.println("Username: " + s); case Integer i when i >= 0 -> System.out.println("Age: " + i); case Integer i -> System.out.println("Invalid age: " + i); case null -> System.out.println("Null input"); default -> System.out.println("Unknown input type"); } } public static void showCodeQualityTips() { System.out.println("\n=== Code Quality Tips ==="); System.out.println(""" ✅ DO: - Use pattern matching to eliminate boilerplate casting - Combine with switch expressions for exhaustive handling - Use guards for additional conditions - Consider sealed classes for exhaustive pattern matching - Use meaningful variable names in patterns ❌ DON'T: - Use pattern variables you don't need - Create overly complex nested patterns - Forget about pattern variable scope rules - Use pattern matching where simple instanceof suffices - Ignore null handling in patterns """); } }

Conclusion

Key Benefits of Pattern Matching for instanceof:

1. Reduced Boilerplate: Eliminates explicit casting
2. Improved Readability: More concise and expressive code
3. Enhanced Safety: Compiler helps prevent type-related bugs
4. Better Maintainability: Clearer intent and structure

When to Use Pattern Matching:

Java Version Support:

• Java 14-15: Preview feature (enable with --enable-preview)
• Java 16+: Standard feature
• Java 21+: Enhanced with switch pattern matching

Pattern matching for instanceof is a significant improvement to Java's type system, making code more concise, readable, and less error-prone. It's particularly powerful when combined with records, sealed classes, and switch expressions.