What happens with a mutable key in HashMap?

package com.bank.demo;

import java.util.*;

public class MutableKeyDemo {
    static class Account {
        String id;
        Account(String id) { this.id = id; }

        @Override public int hashCode() { return id.hashCode(); }
        @Override public boolean equals(Object o) {
            return o instanceof Account a && a.id.equals(this.id);
        }
        @Override public String toString() { return "Account(" + id + ")"; }
    }

    public static void main(String[] args) {
        Map<Account, String> map = new HashMap<>();
        Account key = new Account("SAV2001");

        // Step 1: insert with hash of "SAV2001"
        map.put(key, "Rajesh");
        System.out.println("Before mutation: " + map.get(key)); // Rajesh

        // Step 2: MUTATE the key
        key.id = "CUR3001";

        // Step 3: get() computes hash of "CUR3001" → wrong bucket
        System.out.println("After mutation: " + map.get(key)); // null!

        // Try the original value – also fails
        System.out.println("Original lookup: " + map.get(new Account("SAV2001"))); // null!
        // Why? The entry in the old bucket has key.id = "CUR3001" now.
        // equals("SAV2001") fails because the stored key's id is "CUR3001".

        // Try the new value
        System.out.println("New value lookup: " + map.get(new Account("CUR3001"))); // null!
        // Why? The new hash points to a different bucket where no entry exists.

        // The entry is STUCK
        System.out.println("Size: " + map.size()); // 1 – entry exists!
        System.out.println("Contains key: " + map.containsKey(key)); // false!

        // Only visible during iteration
        for (var entry : map.entrySet()) {
            System.out.println("Iteration found: " + entry.getKey() + " → " + entry.getValue());
        }
    }
}

// Safe keys:
Map<String, String> map1 = new HashMap<>();        // String is immutable
Map<Integer, String> map2 = new HashMap<>();       // Integer is immutable
Map<DayOfWeek, String> map3 = new EnumMap<>(DayOfWeek.class); // enum is immutable

// Safe: records with immutable components
record AccountId(String branch, String number) {} // immutable
Map<AccountId, String> map4 = new HashMap<>();

// UNSAFE: mutable class as key
class MutableAccount { String id; /* no final, has setter */ }

package com.bank.model;

import java.util.Objects;

public final class AccountKey {
    private final String branchCode;
    private final String accountNumber;

    public AccountKey(String branchCode, String accountNumber) {
        this.branchCode = Objects.requireNonNull(branchCode);
        this.accountNumber = Objects.requireNonNull(accountNumber);
    }

    @Override
    public int hashCode() {
        return Objects.hash(branchCode, accountNumber);
    }

    @Override
    public boolean equals(Object o) {
        return o instanceof AccountKey ak
            && ak.branchCode.equals(this.branchCode)
            && ak.accountNumber.equals(this.accountNumber);
    }

    @Override
    public String toString() {
        return branchCode + "-" + accountNumber;
    }

    // No setters! Fields are final!
    public String branchCode() { return branchCode; }
    public String accountNumber() { return accountNumber; }
}

record AccountKey(String branchCode, String accountNumber) {}
// hashCode, equals, and toString are auto-generated
// Fields are final – cannot be mutated

// WRONG: List is mutable – hashCode changes if elements change
Map<List<String>, String> map = new HashMap<>();
List<String> key = new ArrayList<>(List.of("SAV", "2001"));
map.put(key, "Rajesh");
key.add("EXTRA"); // hashCode changes!
System.out.println(map.get(key)); // null! Entry lost.

// CORRECT: use an immutable list or convert to String
Map<List<String>, String> map2 = new HashMap<>();
map2.put(List.of("SAV", "2001"), "Rajesh"); // List.of is immutable