Enums and switch expressions

An enum is a class with a fixed set of instances, created once when the class loads. Each constant is a real object, so an enum can have fields, a constructor (always private) and methods, and == is safe for comparing constants because there is only ever one of each.

enum Size {
    SMALL("S"), MEDIUM("M"), LARGE("L");

    private final String label;
    Size(String label) { this.label = label; }
    String label() { return label; }
}

Every enum gets values() (the constants in declaration order), valueOf(String) (exact, case-sensitive lookup by name), name() and ordinal() (the position, from 0). Enums implement Comparable, and their natural order is declaration order.

1import java.util.*;2 3public class Solution {4    enum Size {5        SMALL("S"), MEDIUM("M"), LARGE("L");6 7        private final String label;8        Size(String label) { this.label = label; }9        String label() { return label; }10    }11 12    public static List<String> describe() {13        List<String> out = new ArrayList<>();14        for (Size s : Size.values()) {15            out.add(s.name() + " ordinal=" + s.ordinal() + " label=" + s.label());16        }17        out.add("SMALL < LARGE: " + (Size.SMALL.compareTo(Size.LARGE) < 0));18        out.add("valueOf(\"MEDIUM\") == MEDIUM: " + (Size.valueOf("MEDIUM") == Size.MEDIUM));19        try {20            Size.valueOf("medium");21        } catch (IllegalArgumentException e) {22            out.add("valueOf(\"medium\"): " + e.getMessage());23        }24        return out;25    }26}

EnumMap and EnumSet are the collections to reach for with enum keys: an EnumMap is an array indexed by ordinal and an EnumSet a bit vector, so both are compact and fast, and both always iterate in declaration order.

switch expressions

The classic switch statement falls through: without a break, execution continues into the next case. Java 14 made the switch expression standard: arrow labels never fall through, one case can list several labels, and the whole switch produces a value.

1import java.util.*;2 3public class Solution {4    enum Level { LOW, MEDIUM, HIGH }5 6    static String oldStyle(Level level) {7        String actions = "";8        switch (level) {9            case HIGH:10                actions += "page ";11                // forgot break: falls into MEDIUM12            case MEDIUM:13                actions += "email ";14                break;15            case LOW:16                actions += "log ";17        }18        return actions.trim();19    }20 21    static String newStyle(Level level) {22        return switch (level) {23            case HIGH -> "page";24            case MEDIUM -> "email";25            case LOW -> "log";26        };27    }28 29    public static List<String> describe() {30        return List.of(31            "statement HIGH -> " + oldStyle(Level.HIGH),32            "expression HIGH -> " + newStyle(Level.HIGH));33    }34}

int days = switch (month) {
    case FEBRUARY -> leapYear ? 29 : 28;
    case APRIL, JUNE, SEPTEMBER, NOVEMBER -> 30;
    default -> {
        log("31-day month");
        yield 31;            // a block produces its value with yield
    }
};

A switch expression must be exhaustive: it has to produce a value for every possible input. Over an enum, listing every constant counts, so no default is needed — and then adding a constant to the enum later makes every such switch fail to compile until the new case is handled. That is the real reason to prefer them: a forgotten case becomes a compile error instead of a silent no-op. (For a switch over an enum with no default, the compiler also inserts a runtime check that throws if a class compiled against an older version of the enum meets a new constant.)

Common mistakes

• Persisting ordinal() (in a database or a file). Inserting a constant in the middle renumbers everything after it; store name() or an explicit code field instead.
• Calling valueOf on user input without handling IllegalArgumentException — it is case-sensitive and throws for any unknown name.
• Sorting enum names as strings when declaration order is the meaning (L, M, S instead of S, M, L).
• A forgotten break in an old-style statement — the second example above.

1import java.util.*;2 3public class Solution {4    enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY }5 6    public static List<String> describe() {7        Map<Day, Integer> meetings = new EnumMap<>(Day.class);8        meetings.put(Day.FRIDAY, 1);9        meetings.put(Day.MONDAY, 3);10        meetings.put(Day.WEDNESDAY, 2);11 12        List<String> names = new ArrayList<>(List.of("FRIDAY", "MONDAY", "WEDNESDAY"));13        Collections.sort(names);                       // alphabetical14        List<Day> days = new ArrayList<>(List.of(Day.FRIDAY, Day.MONDAY, Day.WEDNESDAY));15        Collections.sort(days);                        // declaration order16 17        return List.of("EnumMap: " + meetings, "names sorted: " + names, "days sorted: " + days);18    }19}

What interviewers ask

• Why is an enum a good way to implement a singleton? The JVM creates each constant exactly once, thread-safely, and serialization and reflection cannot create a second one.
• What does a switch expression give you over a switch statement? No fall-through, a result value, several labels per case, and a compile error when a case is missing.
• Why use EnumMap instead of HashMap for enum keys? Array-backed by ordinal: no hashing, less memory, and a predictable iteration order.