Break the map with a mutable key

import java.util.*;

/**
 * CHALLENGE — break the map with a mutable key, then explain it.
 *
 * Run as-is. An entry you just inserted becomes unreachable, while size()
 * still counts it. Nothing throws.
 *
 * TASKS
 *   1. Predict every line of output BEFORE running. Write your prediction down.
 *   2. Run it. Explain precisely why the entry is lost — name the bucket.
 *   3. Fix it. There are two valid fixes and they are not equivalent:
 *        (a) make the key immutable
 *        (b) exclude the mutable field from hashCode()
 *      Implement (a). Then say in a comment what (b) silently costs you.
 *   4. Prove the entry is still physically present even though get() fails.
 */
public class Starter {

    /** A key whose hash depends on a field you can change afterwards. */
    static class OrderKey {
        String region;      // mutable — this is the landmine
        final int orderId;

        OrderKey(String region, int orderId) {
            this.region = region;
            this.orderId = orderId;
        }

        @Override
        public int hashCode() {
            return Objects.hash(region, orderId);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof OrderKey k)) return false;
            return orderId == k.orderId && Objects.equals(region, k.region);
        }

        @Override
        public String toString() {
            return region + "#" + orderId;
        }
    }

    public static void main(String[] args) {
        Map<OrderKey, String> orders = new HashMap<>();

        OrderKey key = new OrderKey("APAC", 1001);
        orders.put(key, "Widget order");

        System.out.println("get before mutation = " + orders.get(key));
        System.out.println("size before         = " + orders.size());

        // somewhere far away, someone "just updates the region"
        key.region = "EMEA";

        System.out.println("get after mutation  = " + orders.get(key));
        System.out.println("containsKey         = " + orders.containsKey(key));
        System.out.println("size after          = " + orders.size());
        System.out.println("remove returns      = " + orders.remove(key));
        System.out.println("size after remove   = " + orders.size());

        // The entry is unreachable by key — but is it gone?
        System.out.print("still iterable      = ");
        for (Map.Entry<OrderKey, String> e : orders.entrySet()) {
            System.out.print(e.getKey() + "=" + e.getValue() + " ");
        }
        System.out.println();
    }
}