The Evolution of Switch in Java: from Statement to Pattern Matching

The evolution of switch in Java illustrates how the language has kept adapting to let developers write more concise, safe, and expressive code. Originally conceived as a simple control-flow mechanism, switch has gone through several transformations — from the traditional switch statement to the modern switch expression with pattern matching — significantly expanding its capabilities and flexibility.

1. The Classic Switch Statement

In early versions of Java, switch was used to test a variable against a fixed set of constant values. It accepted primitive types (like int, char), enum, and later String.

While functional, it required a lot of repetitive code and careful attention to the use of break, which prevented fall through — where execution continues into the next case even after finding a match.

String level = "intermediate";
switch (level) {
    case "beginner":
        System.out.println("You're just getting started.");
        break;
    case "intermediate":
        System.out.println("You already have some experience.");
        break;
    case "advanced":
        System.out.println("You've mastered the language!");
        break;
    default:
        System.out.println("Unknown level.");
}

Common problems:

• Forgetting the break, causing hard-to-track bugs.
• Long, repetitive syntax.
• No support for directly returning values.

2. Switch Expression (Java 12+ / Java 14)

Starting with Java 12, and stabilized in Java 14 through JEP 361, the concept of switch expressions was introduced. With it, switch stops being just a statement and becomes an expression that returns values as well.

Advantages:

• Concise syntax: -> eliminates break and avoids fall through.
• Return values: you can store the switch’s result directly.

int month = 2;
String monthName = switch (month) {
    case 1 -> "January";
    case 2 -> "February";
    case 3 -> "March";
    default -> "Invalid month";
};
System.out.println("The month is: " + monthName);

You can also use blocks for more complex logic:

int number = 5;
String result = switch (number) {
    case 1, 2, 3 -> "Low";
    case 4, 5, 6 -> {
        System.out.println("Mid-range");
        yield "Medium";
    }
    default -> "High";
};

3. Pattern Matching for Switch (Java 17+ / Java 21)

The third stage of this evolution is even more powerful: pattern matching for switch, introduced as a preview in Java 17 and stabilized in Java 21 through JEP 441. This feature turns switch into a tool capable of checking type patterns, extracting variables, and applying conditions directly within the cases.

New capabilities with pattern matching:

• Dynamically testing types: no need for instanceof + cast.
• Inline variable extraction: the value is automatically assigned to the correct type.
• Guards (when): let you add extra conditions.
• Handling null directly.
• Deconstructing records.

Practical example:

Object value = 42;
String result = switch (value) {
    case Integer num && num > 50 -> "Large number";
    case Integer num -> "Small or medium number";
    case String s when s.length() > 3 -> "Long text";
    case String s -> "Short text";
    case null -> "Null value";
    default -> "Other type";
};
System.out.println("Result: " + result);

With a record:

record Person(String name, int age) {}

Object obj = new Person("Ana", 30);

String description = switch (obj) {
    case Person(String name, int age) when age >= 18 -> name + " is an adult.";
    case Person(String name, int age) -> name + " is a minor.";
    default -> "Unknown type.";
};

Syntax Comparison:

When to use each?

The transformation of switch in Java reflects the language’s commitment to evolving without losing compatibility. From a limited, error-prone structure, switch has become a modern, expressive, and versatile tool.