Почему неизменяемость String важна при использовании в качестве ключа?

Почему неизменяемость String важна при использовании в качестве ключа?

Суть проблемы

Ключи в HashMap и других коллекциях должны быть абсолютно стабильными. Если ключ измениться во время работы программы, это приведёт к критическим ошибкам. Вот почему String выбран идеальным кандидатом — он неизменяем (immutable).

Как работает HashMap с ключами

Когда ты добавляешь элемент в HashMap, происходит следующее:

Map<String, Integer> map = new HashMap<>();
map.put("key", 100);

1. HashMap вычисляет hashCode строки "key"
2. По hashCode определяется bucket (корзина) в массиве
3. В этот bucket добавляется пара ключ-значение
4. Для поиска используется как hashCode, так и equals()

Катастрофа, если ключ менялся бы

Представь, что String был изменяем:

// Если бы String был изменяем:
StringBuilder key = new StringBuilder("user123");
Map<StringBuilder, String> map = new HashMap<>();
map.put(key, "John");

// На момент добавления: hashCode = 12345, bucket = 2

// Потом кто-то изменяет ключ:
key.setCharAt(0, 'v');  // "user123" to "vser123"

// Теперь: hashCode = 54321, bucket = 5
// Но данные остались в bucket 2!

// Попытка получить значение:
String result = map.get(new StringBuilder("vser123"));
// null - не найдено! Данные потеряны!

Почему неизменяемость String решает проблему

String — immutable, поэтому:

String key = "user123";
Map<String, String> map = new HashMap<>();
map.put(key, "John");

// Вычислены hashCode и bucket один раз
int bucket = key.hashCode() % bucketSize;  // bucket = 2

// Никто не может изменить строку
// hashCode всегда будет одинаковым
assert key.hashCode() == key.hashCode();  // Всегда true

// Поэтому поиск работает корректно:
String result = map.get("user123");  // "John"

HashCode и Equals — неразрывная пара

Для правильной работы HashMap требуется контракт:

// Контракт hashCode-equals:
if (obj1.equals(obj2)) {
    assert obj1.hashCode() == obj2.hashCode();
}

String гарантирует этот контракт благодаря неизменяемости:

String s1 = new String("test");
String s2 = new String("test");

assert s1.equals(s2);  // true
assert s1.hashCode() == s2.hashCode();  // true

Map<String, Integer> map = new HashMap<>();
map.put(s1, 100);
assert map.get(s2) == 100;  // Работает

Кэширование hashCode

Java даже кэширует hashCode для String благодаря неизменяемости:

public final class String {
    private int hash;  // Кэш хеша
    
    @Override
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            h = computeHash();
            hash = h;
        }
        return h;  // Повторные вызовы вернут кэшированное значение
    }
}

Это возможно только потому, что String не может измениться.

Правила для ключей в коллекциях

1. Используй immutable объекты как ключи
2. String, Integer, Long — идеальные ключи
3. Если создаёшь свой класс — сделай его immutable:
   • final для класса
   • final для всех полей
   • Без setters
   • hashCode и equals реализованы корректно

public final class UserId {
    private final String id;
    
    public UserId(String id) {
        this.id = id;
    }
    
    @Override
    public int hashCode() {
        return id.hashCode();
    }
    
    @Override
    public boolean equals(Object o) {
        return id.equals(((UserId) o).id);
    }
}

Вывод

String неизменяем потому что:

• hashCode никогда не изменится во время жизни объекта
• HashMap гарантирует корректный поиск ключа
• Контракт hashCode-equals всегда соблюдается
• Производительность — hashCode кэшируется
• Безопасность — нельзя случайно испортить ключ