Как изменение ключа влияет на Map

# Влияние изменения ключа на Map в Java

Этот вопрос затрагивает важную концепцию работы с HashMap и другими Map реализациями. Изменение ключа после добавления его в Map может привести к серьезным проблемам и потере данных.

Проблема: Изменяемые ключи (Mutable Keys)

Когда вы добавляете пару (ключ, значение) в Map, контейнер использует hashCode() ключа для определения позиции сохранения. Если после добавления вы измените ключ, его hashCode() изменится, и Map больше не сможет найти это значение.

public class User {
    private String name;
    private int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age); // hashCode зависит от name и age
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        User user = (User) obj;
        return age == user.age && Objects.equals(name, user.name);
    }
    
    // Опасный сеттер!
    public void setName(String name) {
        this.name = name; // Изменяет hashCode!
    }
}

public class Demo {
    public static void main(String[] args) {
        Map<User, String> map = new HashMap<>();
        
        User user = new User("Иван", 30);
        map.put(user, "Инженер");
        
        System.out.println("Данные добавлены: " + map.get(user)); // Инженер
        
        // ОПАСНО: изменяем ключ
        user.setName("Петр"); // hashCode изменился!
        
        // Теперь не можем найти значение
        System.out.println("После изменения: " + map.get(user)); // null!
        
        System.out.println("Размер Map: " + map.size()); // 1 (данные еще там)
    }
}

Результат:

Данные добавлены: Инженер
После изменения: null
Размер Map: 1

Данные физически остаются в Map, но стали недоступными!

Почему это происходит

HashMap использует хеширование для быстрого поиска:

1. При put(key, value): вычисляется hashCode(), определяется bucket (ячейка)
2. Значение сохраняется в этот bucket
3. При get(key): вычисляется новый hashCode()
4. Если hashCode() изменился → ищет в другом bucket → не находит значение

public V put(K key, V value) {
    int hash = hash(key.hashCode()); // Вычисляем hashCode
    int index = hash % capacity;     // Определяем bucket
    // ... сохраняем в buckets[index]
}

public V get(Object key) {
    int hash = hash(key.hashCode()); // Вычисляем hashCode заново
    int index = hash % capacity;     // Ищем в другом bucket!
    // ... если key изменился → не находим
}

Решение 1: Неизменяемые ключи (Immutable Keys)

Правильный подход — делать ключи неизменяемыми (immutable):

public final class User {
    private final String name;  // final
    private final int age;      // final
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        User user = (User) obj;
        return age == user.age && Objects.equals(name, user.name);
    }
    
    // Нет сеттеров! Объект неизменяем
}

Теперь hashCode() никогда не изменится, и Map работает корректно:

Map<User, String> map = new HashMap<>();
User user = new User("Иван", 30);
map.put(user, "Инженер");

// Попытка изменить — невозможно
// user.setName("Петр"); // Compilation error!

System.out.println(map.get(user)); // Инженер (всегда работает)

Решение 2: Использование копии при изменении

Если нужно менять объект, удалите старый ключ и добавьте новый:

Map<User, String> map = new HashMap<>();
User user = new User("Иван", 30);
map.put(user, "Инженер");

// Безопасное изменение
String value = map.remove(user);      // Удаляем старый ключ
user.setName("Петр");                 // Изменяем
map.put(user, value);                 // Добавляем с новым hashCode

System.out.println(map.get(user));    // Инженер (работает!)

Решение 3: TreeMap с Comparable

Если требуется mutability, использую TreeMap, где порядок определяется compareTo(), а не hashCode():

Map<User, String> map = new TreeMap<>((u1, u2) -> 
    u1.getName().compareTo(u2.getName()));

User user = new User("Иван", 30);
map.put(user, "Инженер");

// При изменении hashCode может быть проблема
user.setName("Петр");
// TreeMap также может иметь проблемы, если compareTo зависит от изменяемых полей

Лучшие практики

✅ Всегда делай ключи неизменяемыми (immutable)

• Используй final для полей
• Нет сеттеров
• hashCode() и equals() основаны только на неизменяемых полях

✅ Примеры хороших ключей:

• String, Integer, Long — встроенные неизменяемые типы
• UUID
• LocalDate, LocalDateTime — из java.time
• Пользовательские классы с final полями

❌ Избегай:

• Изменяемых коллекций как ключей (List, Set)
• Классов с сеттерами
• Объектов, чьи hashCode()/equals() зависят от изменяемых полей

Заключение

Изменение ключа в Map приводит к потере доступа к значениям, так как нарушается инвариант хеширования. Вывод простой: всегда используйте неизменяемые (immutable) объекты как ключи в HashMap и других Map реализациях. Это предотвратит трудноуловимые ошибки и обеспечит корректное поведение коллекций.