Instead of simply matching against constant values, switch type patterns allow you to match against the types and their specific characteristics of the evaluated expression. This translates to cleaner, more readable code compared to traditional if-else statements or cumbersome instanceof checks.

Key Features

  • Type patterns: These match against the exact type of the evaluated expression (e.g., case String s).
  • Deconstruction patterns: These extract specific elements from record objects of a certain type (e.g., case Point(int x, int y)).
  • Guarded patterns: These add additional conditions to be met alongside the type pattern, utilizing the when clause (e.g., case String s when s.length() > 5).
  • Null handling: You can now explicitly handle the null case within the switch statement.

Benefits

  • Enhanced Readability: Code becomes more intuitive by directly matching against types and extracting relevant information.
  • Reduced Boilerplate: Eliminate the need for extensive instanceof checks and type casting, leading to cleaner code.
  • Improved Type Safety: Explicit type checks within the switch statement prevent potential runtime errors.
  • Fine-grained Control Flow: The when clause enables precise matching based on both type and additional conditions.

Examples in Action

  1. Type Patterns:

    Number number = 10l;

switch (number) {
   case Integer i -> System.out.printf("%d is an integer!", i);
   case Long l -> System.out.printf("%d is a long!", l);
   default -> System.out.println("Unknown type");
}

    In this example, the switch statement checks the exact type of number using the Long type pattern.

  2. Deconstruction Patterns:

    record Point(int x, int y) {}

Point point = new Point(2, 3);

switch (point) {
   case Point(var x, var y) -> System.out.println("Point coordinates: (" + x + ", " + y + ")");
   default -> System.out.println("Unknown object type");
}

    Here, the deconstruction pattern extracts the x and y coordinates from the Point record object and assigns them to variables within the case block.

  3. Guarded Patterns with the when Clause:

    String name = "John Doe";

switch (name) {
   case String s when s.length() > 5 -> System.out.println("Long name!");
   case String s -> System.out.println("It's a string.");
}

    This example demonstrates a guarded pattern. The first case checks if the evaluated expression is a String and its length is greater than 5 using the when clause.

  4. Null Handling:

    Object object = null;

switch (object) {
 case null -> System.out.println("The object is null.");
 case String s -> System.out.println("It's a string!");
 default -> System.out.println("Unknown object type");
}

    Finally, this example showcases the ability to explicitly handle the null case within the switch statement, improving code safety.

Conclusion

Switch type patterns in Java 21 offer a powerful and versatile way to write concise, readable, and type-safe code. By leveraging its features, including the when clause for guarded patterns, you can significantly enhance the maintainability and expressiveness of your Java applications.