EnumMap and EnumSet in Java: The Fast, Type-Safe Collections You're Probably Not Using

import java.util.EnumMap;
import java.util.Map;

public class CafeOrderTracker {

    // A fixed set of drink sizes — perfect enum candidates
    enum DrinkSize {
        SMALL, MEDIUM, LARGE, EXTRA_LARGE
    }

    public static void main(String[] args) {

        // EnumMap constructor requires the enum's Class so it can
        // allocate a backing array of exactly the right size (4 slots here)
        EnumMap<DrinkSize, Integer> orderCounts = new EnumMap<>(DrinkSize.class);

        // Populating like any normal Map — the difference is in the internals
        orderCounts.put(DrinkSize.SMALL,       42);
        orderCounts.put(DrinkSize.MEDIUM,      78);
        orderCounts.put(DrinkSize.LARGE,       55);
        orderCounts.put(DrinkSize.EXTRA_LARGE, 19);

        System.out.println("=== Today's Order Summary ===");

        // Iteration is GUARANTEED to follow enum declaration order (SMALL first)
        // This is NOT guaranteed with HashMap — huge win for readability
        for (Map.Entry<DrinkSize, Integer> entry : orderCounts.entrySet()) {
            System.out.printf("%-15s : %d orders%n",
                entry.getKey(), entry.getValue());
        }

        // Updating a count — internally this is just array[2] = array[2] + 1
        orderCounts.merge(DrinkSize.LARGE, 1, Integer::sum);
        System.out.println("\nAfter one more LARGE order: " + orderCounts.get(DrinkSize.LARGE));

        // Check which sizes are currently tracked
        System.out.println("\nTracked sizes: " + orderCounts.keySet());

        // computeIfAbsent works exactly as on HashMap
        orderCounts.computeIfAbsent(DrinkSize.SMALL, k -> 0);
        System.out.println("SMALL (already present, unchanged): " + orderCounts.get(DrinkSize.SMALL));
    }
}

import java.util.EnumSet;
import java.util.Set;

public class RolePermissionSystem {

    // Permissions modelled as an enum — the ideal candidate for EnumSet
    enum Permission {
        READ, WRITE, DELETE, PUBLISH, ADMIN
    }

    // Role definitions using EnumSet.of() — clear, readable, efficient
    static final Set<Permission> VIEWER_PERMISSIONS =
        EnumSet.of(Permission.READ);

    static final Set<Permission> EDITOR_PERMISSIONS =
        EnumSet.of(Permission.READ, Permission.WRITE);

    static final Set<Permission> PUBLISHER_PERMISSIONS =
        EnumSet.of(Permission.READ, Permission.WRITE, Permission.PUBLISH);

    // Admin gets everything — allOf() creates a full set in one shot
    static final Set<Permission> ADMIN_PERMISSIONS =
        EnumSet.allOf(Permission.class);

    public static boolean canPerform(Set<Permission> userPermissions,
                                      Permission requiredPermission) {
        // Under the hood for two EnumSets this is a single bitwise AND — extremely fast
        return userPermissions.contains(requiredPermission);
    }

    public static Set<Permission> combinePermissions(Set<Permission> roleA,
                                                      Set<Permission> roleB) {
        // EnumSet.copyOf + addAll is one bitwise OR internally
        Set<Permission> combined = EnumSet.copyOf(roleA);
        combined.addAll(roleB); // bitwise OR on the backing long
        return combined;
    }

    public static void main(String[] args) {

        System.out.println("=== Permission Check ===");
        System.out.println("Viewer can READ?    " + canPerform(VIEWER_PERMISSIONS, Permission.READ));
        System.out.println("Viewer can DELETE?  " + canPerform(VIEWER_PERMISSIONS, Permission.DELETE));
        System.out.println("Editor can WRITE?   " + canPerform(EDITOR_PERMISSIONS, Permission.WRITE));
        System.out.println("Editor can PUBLISH? " + canPerform(EDITOR_PERMISSIONS, Permission.PUBLISH));

        System.out.println("\n=== Admin Permissions ===");
        System.out.println("Admin has: " + ADMIN_PERMISSIONS);

        // noneOf creates an empty set — useful as a starting point to build up
        Set<Permission> temporaryAccess = EnumSet.noneOf(Permission.class);
        temporaryAccess.add(Permission.READ);
        temporaryAccess.add(Permission.WRITE);
        System.out.println("\nTemporary access: " + temporaryAccess);

        // range() selects a contiguous slice of enum constants by declaration order
        Set<Permission> readToPublish = EnumSet.range(Permission.READ, Permission.PUBLISH);
        System.out.println("READ through PUBLISH: " + readToPublish);

        // Combine editor + publisher roles
        Set<Permission> combinedRole = combinePermissions(EDITOR_PERMISSIONS, PUBLISHER_PERMISSIONS);
        System.out.println("\nCombined editor+publisher: " + combinedRole);

        // complementOf gives everything NOT in the set
        Set<Permission> nonAdminPerms = EnumSet.complementOf((EnumSet<Permission>) ADMIN_PERMISSIONS);
        System.out.println("Complement of ADMIN (empty): " + nonAdminPerms);
    }
}

import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Map;
import java.util.Set;

public class OrderStateMachine {

    enum OrderStatus {
        PENDING, CONFIRMED, PROCESSING, SHIPPED, DELIVERED, CANCELLED
    }

    // The transition table: for each status, which statuses can it move to?
    // EnumMap as the outer container, EnumSet as the inner — best of both worlds
    private static final Map<OrderStatus, Set<OrderStatus>> VALID_TRANSITIONS;

    static {
        VALID_TRANSITIONS = new EnumMap<>(OrderStatus.class);

        // Each entry defines legal forward transitions from that state
        VALID_TRANSITIONS.put(OrderStatus.PENDING,
            EnumSet.of(OrderStatus.CONFIRMED, OrderStatus.CANCELLED));

        VALID_TRANSITIONS.put(OrderStatus.CONFIRMED,
            EnumSet.of(OrderStatus.PROCESSING, OrderStatus.CANCELLED));

        VALID_TRANSITIONS.put(OrderStatus.PROCESSING,
            EnumSet.of(OrderStatus.SHIPPED, OrderStatus.CANCELLED));

        VALID_TRANSITIONS.put(OrderStatus.SHIPPED,
            EnumSet.of(OrderStatus.DELIVERED));  // Can't cancel once shipped

        // Terminal states — no outgoing transitions
        VALID_TRANSITIONS.put(OrderStatus.DELIVERED, EnumSet.noneOf(OrderStatus.class));
        VALID_TRANSITIONS.put(OrderStatus.CANCELLED,  EnumSet.noneOf(OrderStatus.class));
    }

    private OrderStatus currentStatus;

    public OrderStateMachine(OrderStatus initialStatus) {
        this.currentStatus = initialStatus;
    }

    public boolean transitionTo(OrderStatus nextStatus) {
        // contains() on an EnumSet is a bitwise AND — as fast as it gets
        Set<OrderStatus> allowedNext = VALID_TRANSITIONS.get(currentStatus);

        if (allowedNext.contains(nextStatus)) {
            System.out.printf("Transition: %s → %s ✓%n", currentStatus, nextStatus);
            currentStatus = nextStatus;
            return true;
        } else {
            System.out.printf("REJECTED: %s → %s is not a valid transition%n",
                currentStatus, nextStatus);
            return false;
        }
    }

    public OrderStatus getStatus() { return currentStatus; }

    public static void main(String[] args) {
        OrderStateMachine order = new OrderStateMachine(OrderStatus.PENDING);
        System.out.println("Initial status: " + order.getStatus());
        System.out.println();

        // Happy path
        order.transitionTo(OrderStatus.CONFIRMED);
        order.transitionTo(OrderStatus.PROCESSING);
        order.transitionTo(OrderStatus.SHIPPED);

        // Illegal jump — can't go from SHIPPED back to PENDING
        order.transitionTo(OrderStatus.PENDING);

        // Can't cancel after shipping either
        order.transitionTo(OrderStatus.CANCELLED);

        // Legal final step
        order.transitionTo(OrderStatus.DELIVERED);

        System.out.println("\nFinal status: " + order.getStatus());

        // Demonstrate terminal state — no further transitions possible
        order.transitionTo(OrderStatus.CANCELLED);
    }
}