Что произойдет если ключ в Map будет мутабельным?

Мутабельные ключи в Map: проблемы и последствия

Использование мутабельных (изменяемых) объектов в качестве ключей в Map — это серьезная ошибка, которая приводит к непредсказуемому поведению и потере данных. Это нарушает фундаментальный контракт Map.

Как работает HashMap

Для понимания проблемы нужно знать, как HashMap находит значения:

1. Вычисляется хеш-код ключа: hash = key.hashCode()
2. На основе хеша определяется бакет (позиция в массиве)
3. В этом бакете ищется элемент с key.equals(lookupKey) == true

// Внутри HashMap (упрощено)
public V get(Object key) {
    int hash = hash(key.hashCode());
    int index = hash & (table.length - 1);
    
    Entry<K, V> entry = table[index];
    while (entry != null) {
        if (entry.hash == hash && 
            (entry.key == key || entry.key.equals(key))) {
            return entry.value;  // Найдено!
        }
        entry = entry.next;
    }
    return null;  // Не найдено
}

Проблема: Изменение ключа

Если изменить ключ после его добавления в Map, то hashCode() вернёт другое значение, и ключ окажется в неправильном бакете:

public class MutableKey {
    private String value;
    
    MutableKey(String value) {
        this.value = value;
    }
    
    @Override
    public int hashCode() {
        return value.hashCode();
    }
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof MutableKey)) return false;
        return value.equals(((MutableKey) o).value);
    }
    
    public void setValue(String newValue) {
        this.value = newValue;  // ОПАСНО!
    }
    
    public String getValue() {
        return value;
    }
}

public class MutableKeyProblem {
    public static void main(String[] args) {
        Map<MutableKey, String> map = new HashMap<>();
        
        MutableKey key = new MutableKey("original");
        map.put(key, "value1");
        
        System.out.println("Initial state:");
        System.out.println("Contains key: " + map.containsKey(key));  // true
        System.out.println("Get value: " + map.get(key));             // value1
        System.out.println("Size: " + map.size());                    // 1
        
        // ПРОБЛЕМА: Изменяем ключ
        key.setValue("modified");
        
        System.out.println("\nAfter mutation:");
        System.out.println("Contains key: " + map.containsKey(key));  // false!
        System.out.println("Get value: " + map.get(key));             // null!
        System.out.println("Size: " + map.size());                    // 1 (элемент все еще там)
        
        // Элемент заблокирован в неправильном бакете
        for (MutableKey k : map.keySet()) {
            System.out.println("Key in map: " + k.getValue());
        }
    }
}

// Вывод:
// Initial state:
// Contains key: true
// Get value: value1
// Size: 1
//
// After mutation:
// Contains key: false!
// Get value: null!
// Size: 1
// Key in map: modified

Детальное объяснение проблемы

public class DetailedMutableKeyExample {
    static class Key {
        int id;
        
        Key(int id) {
            this.id = id;
        }
        
        @Override
        public int hashCode() {
            System.out.println("hashCode() called for id=" + id);
            return id;
        }
        
        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Key)) return false;
            return id == ((Key) o).id;
        }
    }
    
    public static void main(String[] args) {
        Map<Key, String> map = new HashMap<>();
        Key key = new Key(1);
        
        System.out.println("=== Adding to map ===");
        map.put(key, "value1");  // hashCode() called: 1 -> bucket 1
        // Ключ помещен в bucket для хеша 1
        
        System.out.println("\n=== Getting from map ===");
        String result = map.get(key);  // hashCode() called: 1 -> bucket 1
        System.out.println("Result: " + result);  // value1 (найдено в bucket 1)
        
        System.out.println("\n=== Mutating key ===");
        key.id = 2;  // Меняем ключ!
        
        System.out.println("\n=== Getting again ===");
        result = map.get(key);  // hashCode() called: 2 -> bucket 2
        System.out.println("Result: " + result);  // null!
        // Ищет в bucket 2, но ключ находится в bucket 1!
    }
}

// Вывод:
// === Adding to map ===
// hashCode() called for id=1
//
// === Getting from map ===
// hashCode() called for id=1
// Result: value1
//
// === Mutating key ===
//
// === Getting again ===
// hashCode() called for id=2
// Result: null

Последствия использования мутабельных ключей

1. Потеря доступа к значениям

Map<List<Integer>, String> map = new HashMap<>();
List<Integer> key = new ArrayList<>(Arrays.asList(1, 2, 3));
map.put(key, "data");

key.add(4);  // Меняем ключ!
map.get(key);  // null - потеряли доступ!

2. Логические ошибки в коде

map.containsKey(key);  // Может вернуть false
map.remove(key);       // Может ничего не удалить
map.size();            // Может быть неправильный размер

3. Утечки памяти

// Элементы не удаляются, т.к. containsKey/remove не работают
Map<MutableKey, byte[]> cache = new HashMap<>();
for (int i = 0; i < 1000000; i++) {
    MutableKey key = new MutableKey(i);
    cache.put(key, new byte[1024]);
    key.id = i + 1;  // Мутация!
    // Старые элементы остаются в памяти, недоступные для очистки
}

4. Непредсказуемое поведение в многопоточности

Map<MutableKey, String> map = new HashMap<>();
// Поток 1: добавляет ключи
// Поток 2: меняет ключи
// Результат: недетерминированное поведение, race conditions

Правильное решение: неизменяемые ключи

1. Использование встроенных неизменяемых типов

// String (неизменяемый)
Map<String, String> map1 = new HashMap<>();
map1.put("key1", "value1");

// Integer, Double и другие wrapper классы (неизменяемые)
Map<Integer, String> map2 = new HashMap<>();
map2.put(1, "value1");

// UUID (неизменяемый)
Map<UUID, String> map3 = new HashMap<>();
map3.put(UUID.randomUUID(), "value1");

2. Создание собственного неизменяемого класса

public final class ImmutableKey {  // final - нельзя наследоваться
    private final String value;     // private final - нельзя менять
    
    public ImmutableKey(String value) {
        this.value = Objects.requireNonNull(value);
    }
    
    @Override
    public int hashCode() {
        return value.hashCode();
    }
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ImmutableKey)) return false;
        return value.equals(((ImmutableKey) o).value);
    }
    
    public String getValue() {
        return value;  // Безопасно вернуть value
    }
}

Map<ImmutableKey, String> map = new HashMap<>();
ImmutableKey key = new ImmutableKey("mykey");
map.put(key, "myvalue");
// key не может быть изменен, все работает корректно

3. Использование Collections.unmodifiableMap()

Map<String, String> original = new HashMap<>();
original.put("key", "value");

// Защита от внешних изменений
Map<String, String> immutable = Collections.unmodifiableMap(original);
// immutable.put(...);  // Выбросит UnsupportedOperationException

Правила для ключей в Map

public final class SafeKey {
    private final int id;
    private final String name;
    
    public SafeKey(int id, String name) {
        this.id = id;
        this.name = Objects.requireNonNull(name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof SafeKey)) return false;
        SafeKey that = (SafeKey) o;
        return id == that.id && Objects.equals(name, that.name);
    }
}

// Использование
Map<SafeKey, String> map = new HashMap<>();
SafeKey key = new SafeKey(1, "test");
map.put(key, "value");
// Работает корректно, т.к. ключ неизменяемый

Чек-лист при создании класса для использования как ключ

• Класс объявлен как final (или методы hashCode/equals final)
• Все поля private final
• hashCode() зависит только от final полей
• equals() реализован корректно
• Класс неизменяемый (нет setters)
• Все поля либо примитивы, либо неизменяемые объекты
• Thread-safe

Вывод: Никогда не используй мутабельные объекты как ключи в Map! Это приводит к потере данных и непредсказуемому поведению. Используй только неизменяемые типы (String, Integer, UUID, свои final классы с final полями).