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

Мутабельные объекты как ключи в HashMap

Краткий ответ

Использовать мутабельные объекты в качестве ключей в HashMap, HashSet или других hash-based коллекциях — это критическая ошибка. Это приведёт к потере данных и непредсказуемому поведению.

Почему это опасно

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

// HashMap хранит пары (hash, value)
// Когда вы добавляете key:
// 1. Вычисляется hash = key.hashCode()
// 2. Этот hash определяет bucket
// 3. key и value хранятся в этом bucket'е

Map<String, String> map = new HashMap<>();
map.put("john", "Engineer");
// hash("john") = 3291 → bucket 3291
// Сохраняется: bucket[3291] = ("john", "Engineer")

Проблема с мутабельным ключом

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);
    }
    
    @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);
    }
    
    // setter'ы — это проблема!
    public void setName(String name) {
        this.name = name;
    }
}

// Демонстрация проблемы
User user = new User("Alice", 30);
Map<User, String> map = new HashMap<>();
map.put(user, "Software Engineer");

// Вывод: {User(Alice,30)=Software Engineer}
System.out.println(map);

// ОПАСНО: меняем имя ключа!
user.setName("Bob");

// Теперь hashCode изменился!
int oldHash = Objects.hash("Alice", 30);  // 12345
int newHash = Objects.hash("Bob", 30);    // 67890

// Но HashMap думает, что ключ всё ещё в старом bucket!
// Поэтому get() не найдёт значение
System.out.println(map.get(user));  // null! (должно быть "Software Engineer")

// Более того, объект остался в старом bucket
System.out.println(map);  // {User(Bob,30)=Software Engineer}
// Но map.get(new User("Bob", 30)) вернёт null!

// Почему? Потому что новый объект с hash=67890 будет искать в bucket 67890
// А старый объект всё ещё в bucket 12345

Практический пример проблемы

public class MutableKeyProblem {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        Map<List<Integer>, String> cache = new HashMap<>();
        
        cache.put(list, "Original Value");
        System.out.println("Before mutation: " + cache.get(list));  // Original Value
        
        // Изменяем список (мутируем ключ)
        list.add(4);
        
        // hashCode изменился → поиск в неправильном bucket!
        System.out.println("After mutation: " + cache.get(list));   // null
        
        // Но значение всё ещё в map!
        System.out.println("Map size: " + cache.size());  // 1
        System.out.println("Map contents: " + cache);  // Видим значение
        
        // Пытаемся добавить снова
        cache.put(list, "New Value");
        System.out.println("Map size: " + cache.size());  // 2 (дублировал ключ!)
    }
}

Вывод программы:

Before mutation: Original Value
After mutation: null
Map size: 1
Map contents: {[1, 2, 3, 4]=Original Value}
Map size: 2

Как избежать этой проблемы

1. Используй иммутабельные классы как ключи

// ✅ String — иммутабелен (не может изменяться)
Map<String, Integer> counters = new HashMap<>();
counters.put("requests", 1000);

// ✅ Integer, Long, UUID — иммутабельны
Map<UUID, User> userMap = new HashMap<>();
userMap.put(UUID.randomUUID(), user);

// ✅ LocalDate — иммутабелен
Map<LocalDate, List<Event>> calendar = new HashMap<>();
calendar.put(LocalDate.now(), events);

2. Создай иммутабельный класс для ключа

public final class ImmutableUser {  // final — не может быть наследован
    private final String name;      // final — не может быть изменён
    private final int age;
    
    public ImmutableUser(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Только getters, БЕЗ setters!
    public String getName() { return name; }
    public int getAge() { return 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;
        ImmutableUser user = (ImmutableUser) obj;
        return age == user.age && Objects.equals(name, user.name);
    }
}

// Теперь безопасно использовать как ключ
Map<ImmutableUser, String> jobs = new HashMap<>();
jobs.put(new ImmutableUser("Alice", 30), "Engineer");
// Никто не может изменить ключ, так что всё работает

3. Используй значения вместо ключей

// ❌ Плохо: мутабельный объект как ключ
User user = new User("Alice", 30);
Map<User, String> map = new HashMap<>();
map.put(user, "Engineer");
user.setName("Bob");  // Проблема!

// ✅ Хорошо: иммутабельный ID как ключ
Map<Long, User> userMap = new HashMap<>();
User user = new User(1L, "Alice", 30);
userMap.put(user.getId(), user);
// Даже если изменишь user.setName(), ID остаётся неизменным

Правило для hashCode/equals

/**
 * КРИТИЧЕСКОЕ ПРАВИЛО:
 * Если класс используется как ключ в HashMap/HashSet,
 * то:
 * 1. Все поля, используемые в hashCode(), ДОЛЖНЫ быть иммутабельны
 * 2. Все поля, используемые в equals(), ДОЛЖНЫ быть иммутабельны
 * 3. Класс ДОЛЖЕН переопределять оба метода вместе
 */

public class CorrectKey {
    private final String id;      // ✅ final
    private final LocalDate date; // ✅ final
    
    public CorrectKey(String id, LocalDate date) {
        this.id = Objects.requireNonNull(id);
        this.date = Objects.requireNonNull(date);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id, date);
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof CorrectKey)) return false;
        CorrectKey that = (CorrectKey) obj;
        return Objects.equals(this.id, that.id) && 
               Objects.equals(this.date, that.date);
    }
}

Java документация

Из JavaDoc HashMap:

Note: great care must be exercised if mutable objects are used as map keys. The behavior of a map is not specified if the value of an object is changed in a manner that affects equals comparisons while the object is a key in the map.

Перевод: Критическая осторожность необходима, если использовать мутабельные объекты. Поведение не определено, если значение изменится во время нахождения в map.

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

1. Всегда используй иммутабельные классы как ключи
2. Если нужно менять данные, используй ID (Long, String, UUID) как ключ
3. Помечай ключевые поля как final
4. Не пиши setters для полей, используемых в hashCode()/equals()
5. Тестируй: добавляй в map, меняй объект, проверяй что ломается

Итоговый вывод

Мутабельные объекты как ключи = потеря данных и баги, которые очень сложно отловить. Используй иммутабельные классы (String, Integer, UUID) или создавай свои иммутабельные классы с final полями.