Всегда ли нужен неизменяемый ключ в HashMap при работе в одном потоке?

# HashMap и неизменяемость ключей в однопоточной среде

Ответ: технически нет, но это плохая идея. Давайте разберёмся, почему.

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

HashMap хранит пары ключ-значение, используя хеш-функцию для поиска элемента:

public V get(Object key) {
    int hash = hash(key.hashCode());
    // Поиск в бакете с индексом hash
    // Затем сравнение ключей через equals()
}

Алгоритм поиска

1. Вычисляется hashCode() ключа → получается индекс бакета
2. В бакете ищется элемент с одинаковым hashCode()
3. Для найденных элементов проверяется equals()

Проблема с изменяемыми ключами

public class MutableKey {
    private String value;
    
    public MutableKey(String value) {
        this.value = value;
    }
    
    @Override
    public int hashCode() {
        return value.hashCode();
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MutableKey that = (MutableKey) o;
        return value.equals(that.value);
    }
    
    public void setValue(String value) {
        this.value = value;
    }
}

// ПРОБЛЕМА В ОДНОПОТОЧНОЙ СРЕДЕ
public class Main {
    public static void main(String[] args) {
        Map<MutableKey, String> map = new HashMap<>();
        
        MutableKey key = new MutableKey("initial");
        map.put(key, "value1");
        
        // key.hashCode() = hash("initial") = X
        // Элемент находится в бакете X
        
        System.out.println(map.get(key)); // "value1" — работает!
        
        // ИЗМЕНЯЕМ КЛЮЧ!
        key.setValue("modified");
        
        // key.hashCode() = hash("modified") = Y (другой индекс!)
        // HashMap ищет в бакете Y, но элемент в бакете X
        
        System.out.println(map.get(key)); // null — потеря данных!
        System.out.println(map.containsKey(key)); // false
        
        // Но элемент всё ещё в памяти
        System.out.println(map.size()); // 1
    }
}

Почему это проблема даже в одном потоке

Нарушение контракта Map

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

key.setValue("b");

// Контракт нарушен!
assert map.get(key) != null; // FAIL!

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

MutableKey key = new MutableKey("initial");
map.put(key, "huge_data");

key.setValue("modified");
// Теперь "huge_data" недоступна, но занимает память
// Невозможно удалить, т.к. hashCode изменился

Непредсказуемое поведение

MutableKey key = new MutableKey("a");
map.put(key, "v1");

key.setValue("b");
map.put(key, "v2");

// Теперь в HashMap ДВА элемента с одним объектом!
System.out.println(map.size()); // 2

key.setValue("a");
System.out.println(map.get(key)); // "v1" или "v2"? НЕОПРЕДЕЛЕНО!

Правильный подход

1. Неизменяемые ключи (ПРАВИЛЬНО)

public final class ImmutableKey {
    private final String value;
    private final int hash;
    
    public ImmutableKey(String value) {
        this.value = value;
        this.hash = value.hashCode();
    }
    
    @Override
    public int hashCode() {
        return hash; // Всегда одно значение
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ImmutableKey that = (ImmutableKey) o;
        return value.equals(that.value);
    }
}

// Использование
Map<ImmutableKey, String> map = new HashMap<>();
ImmutableKey key = new ImmutableKey("test");
map.put(key, "value");
System.out.println(map.get(key)); // "value" — всегда работает

2. Если нужна изменяемость — используй другую структуру

// Опция 1: WeakHashMap для объектов, которые могут быть удалены
Map<Object, String> map = new WeakHashMap<>();

// Опция 2: Вынеси изменяемую часть
public class Config {
    private final String id; // неизменяемый ключ
    private String settings; // изменяемое значение
}
Map<String, Config> map = new HashMap<>();

// Опция 3: Используй индекс вместо объекта
List<Config> configs = new ArrayList<>();
int index = 0; // ключ

3. Правило для equals() и hashCode()

// ✅ ПРАВИЛЬНО: базируются на неизменяемых полях
public class User {
    private final String id;      // неизменяемо
    private String name;           // может меняться
    
    @Override
    public int hashCode() {
        return id.hashCode();      // только id
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id.equals(user.id); // только id
    }
}

Заключение

Вывод: Изменяемые ключи работают в одном потоке, но это анти-паттерн, который приводит к:

1. ❌ Потере данных — невозможно найти элемент после изменения
2. ❌ Утечкам памяти — недоступные элементы занимают место
3. ❌ Непредсказуемому поведению — нарушение контракта Map
4. ❌ Сложности отладки — ошибки зависят от последовательности операций

Правило: используй как ключи только неизменяемые объекты (String, Integer, UUID, или custom immutable классы). Если нужна изменяемость — это признак неправильного дизайна.