Java switch expression multiple cases

Java switch expressions, introduced as a preview in Java 12 and finalized in Java 14, allow you to handle multiple cases with a more concise and expressive syntax. When you need to map several input values to the same result, the java switch expression multiple cases feature lets you list multiple labels on a single arrow branch, reducing repetition and improving readability.

The Arrow Syntax for Multiple Case Labels

The arrow syntax (->) is the core of switch expressions. To handle multiple cases that share the same outcome, you list the case labels separated by commas before the arrow. This is a direct replacement for the traditional fall-through pattern where multiple case statements were stacked together.

int result = switch (day) {
    case MONDAY, FRIDAY -> 1;
    case TUESDAY, THURSDAY -> 2;
    case WEDNESDAY -> 3;
    default -> 0;
};

In this example, MONDAY and FRIDAY both map to 1. The comma-separated labels are evaluated in order, and if any matches, the expression after the arrow is executed. There is no fall-through: each arrow branch is independent and must produce a value (or throw an exception). This eliminates the need for break statements and reduces the risk of accidental fall-through bugs.

The arrow syntax also works with statements, not just expressions. If you need to execute multiple statements or perform logic before producing a value, you use a block with yield.

Returning Values with yield

When a switch expression branch requires more than a single expression, you use a block and the yield keyword to return a value. yield is similar to return but is specific to switch expressions. It exits the branch and provides the value to the switch expression.

int result = switch (day) {
    case MONDAY, FRIDAY -> {
        int hours = 8;
        yield hours * 2;
    }
    case TUESDAY, THURSDAY -> {
        int hours = 6;
        yield hours * 2;
    }
    default -> 0;
};

Here, each block computes a value and yields it. The yield keyword is mandatory inside a block; you cannot use return because the switch is an expression, not a method. This makes the control flow explicit and prevents accidental side effects.

How Switch Expressions Differ from switch Statements

The traditional switch statement uses colons and break to prevent fall-through. It does not produce a value, and multiple cases often require duplication or fall-through tricks.

int result;
switch (day) {
    case MONDAY:
    case FRIDAY:
        result = 1;
        break;
    case TUESDAY:
    case THURSDAY:
        result = 2;
        break;
    default:
        result = 0;
}

Switch expressions change this in several ways. First, they always produce a value, so you assign the result directly. Second, arrow branches do not fall through, so you never need break. Third, the compiler enforces exhaustiveness: for enums, you must cover all constants or provide a default; for other types, a default is required. This makes the code safer and more predictable.

Another difference is that switch expressions can be used as expressions in assignments, method arguments, and return statements. This often leads to more compact and readable code.

Practical Example: Mapping Days to Workload

Consider a method that returns a workload description based on the day of the week. With multiple case labels, the logic becomes straightforward.

public String workload(Day day) {
    return switch (day) {
        case MONDAY, TUESDAY -> "Heavy";
        case WEDNESDAY, THURSDAY -> "Medium";
        case FRIDAY -> "Light";
        case SATURDAY, SUNDAY -> "Rest";
    };
}

This example uses an enum Day with all seven constants, so no default is needed. The compiler checks that every enum value is handled. If you add a new day to the enum, the switch expression will fail to compile until you update it, which is a valuable maintainability benefit.

If you were using a traditional switch statement, you would need to write separate case lines for each day and manage break statements. The switch expression reduces the code to a single line per group, making the mapping explicit and easier to review.

Compatibility and Language Version Requirements

Switch expressions are a standard feature in Java 14 and later. The arrow syntax and yield keyword are part of this feature. If your project uses an earlier Java version, you cannot use switch expressions without enabling preview features (Java 12 and 13). For production code, you should target Java 14 or newer.

When working with multiple case labels, there is no additional version requirement beyond the switch expression itself. The comma-separated labels are part of the same syntax. However, be aware that some older IDEs or build tools may not fully support the syntax if they are not updated.

If you are maintaining code that must run on Java 8 or 11, you will need to stick with traditional switch statements. In that case, the fall-through pattern is the only way to group cases, but you can mitigate the risk of missing break by using a helper method or a map-based approach.

Common Mistakes and Edge Cases

One common mistake is using a colon (:) instead of an arrow (->) when trying to use multiple case labels. The colon syntax does not support comma-separated labels; it expects each case on its own line. Mixing the two styles will cause a compilation error.

Another mistake is forgetting yield inside a block. If you write a block without yield, the compiler reports that the branch does not return a value. For example:

int result = switch (day) {
    case MONDAY, FRIDAY -> {
        int x = 1;
        x++; // no yield
    }
    default -> 0;
};

This fails because the block does not produce a value. Always ensure that every block ends with a yield statement.

Edge cases also arise with null values. A switch expression throws NullPointerException if the selector expression is null. This is consistent with traditional switch statements, but it is worth remembering when using switch expressions in code that may receive null.

Finally, be careful with exhaustiveness. For non-enum types, you must include a default branch. The compiler will not enforce exhaustiveness for String, Integer, or other types. Omitting default is a compile-time error, so you cannot accidentally leave a gap.

Readability and Maintainability Considerations

The main advantage of using multiple case labels in a switch expression is that it groups related inputs into a single branch. This reduces duplication and makes the mapping between inputs and outputs immediately visible. When you later need to change the behavior for a group of cases, you only edit one branch instead of multiple case lines.

Switch expressions also encourage a functional style. Because they produce a value, they can be used directly in assignments and method calls, eliminating temporary variables and mutable state. This often leads to shorter methods and fewer opportunities for bugs.

However, switch expressions are not always the best choice. If the logic for each case is complex and involves many side effects, a traditional switch statement or a polymorphic approach may be clearer. Use switch expressions when the mapping is straightforward and the branches are relatively short. For long blocks, consider extracting each branch into a separate method to keep the switch readable.

Another maintainability consideration is that switch expressions are compile-time checked for exhaustiveness when used with enums. This is a strong guarantee that prevents runtime surprises. For other types, the default branch acts as a safety net, but you must remember to include it.

In summary, the java switch expression multiple cases feature is a powerful tool for writing concise and safe branching logic. By understanding the arrow syntax, yield, and the differences from traditional switch statements, you can use it effectively in your Java code.