Меняется ли hashCode у иммутабельных объектов

Иммутабельность и hashCode: ключевой контракт

Это один из фундаментальных принципов Java, и ответ: НЕ, hashCode не должен меняться. Давайте разберемся глубоко.

Основной контракт hashCode()

// Из документации Object.hashCode():
// "If two objects are equal according to the equals(Object) method,
// then calling the hashCode method on each of the two objects
// must produce the same integer result."

public class User {
    private final String email;  // Иммутабельное поле
    private final int age;        // Иммутабельное поле
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User user)) return false;
        return age == user.age && Objects.equals(email, user.email);
    }
    
    @Override
    public int hashCode() {
        // hashCode зависит от тех же полей, что и equals()
        return Objects.hash(email, age);
    }
}

Критическое требование:

• Если obj1.equals(obj2) → obj1.hashCode() == obj2.hashCode()
• Если состояние объекта не меняется → hashCode() не меняется

Почему hashCode не меняется для иммутабельных объектов

public final class ImmutableUser {
    private final String email;  // final
    private final int age;        // final
    
    public ImmutableUser(String email, int age) {
        this.email = Objects.requireNonNull(email);
        this.age = age;
        // После конструктора - никаких изменений
    }
    
    // Нет setter'ов - нельзя изменить поля
    
    @Override
    public int hashCode() {
        return Objects.hash(email, age);
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ImmutableUser user)) return false;
        return age == user.age && Objects.equals(email, user.email);
    }
}

Почему это гарантирует стабильность:

• Поля final → не могут изменяться
• hashCode() вычисляется от этих полей
• Результат вычисления всегда один и тот же

Практический пример: использование в HashMap

public class HashMapWithImmutable {
    public static void main(String[] args) {
        HashMap<ImmutableUser, String> map = new HashMap<>();
        
        ImmutableUser user1 = new ImmutableUser("john@example.com", 30);
        map.put(user1, "Some data");
        
        // Получаем значение - hashCode одинаковый
        String value = map.get(user1);
        System.out.println(value);  // "Some data"
        
        // hashCode не изменился
        System.out.println("hashCode: " + user1.hashCode());
        // Если добавим user1 в HashMap снова - найдется в том же бакете
    }
}

Антипаттерн: мутабельные объекты в HashMap

public class MutableUser {  // НЕ final
    private String email;
    private int age;
    
    // Есть setter'ы
    public void setEmail(String email) {
        this.email = email;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(email, age);
    }
}

public class MutableHashMapProblem {
    public static void main(String[] args) {
        HashMap<MutableUser, String> map = new HashMap<>();
        
        MutableUser user = new MutableUser("john@example.com", 30);
        int originalHash = user.hashCode();
        
        map.put(user, "Some data");
        System.out.println("Stored with hash: " + originalHash);
        
        // ❌ ОПАСНО: меняем объект после добавления в HashMap
        user.setEmail("jane@example.com");
        
        // hashCode поменялся!
        int newHash = user.hashCode();
        System.out.println("New hash: " + newHash);
        
        // ❌ Не найдем значение!
        String value = map.get(user);
        System.out.println(value);  // null - ОШИБКА!
        
        // ❌ Но объект есть в map'е
        System.out.println(map.containsValue("Some data"));  // true
    }
}

Что произошло:

1. Добавили user в HashMap в бакет с hash = 1234567
2. Изменили поле email
3. hashCode стал 7654321
4. При поиске - ищем в бакете 7654321
5. Но объект в бакете 1234567
6. Результат: data потерян!

Как это связано с equals() и hashCode()

// Абсолютный закон Java:
// Если переопределил equals() - ОБЯЗАТЕЛЬНО переопредели hashCode()

public final class GoodPractice {
    private final String id;     // final
    private final String name;   // final
    
    @Override
    public boolean equals(Object o) {
        // equals зависит от id и name
        if (!(o instanceof GoodPractice that)) return false;
        return Objects.equals(this.id, that.id) &&
               Objects.equals(this.name, that.name);
    }
    
    @Override
    public int hashCode() {
        // hashCode ТАКЖЕ зависит от id и name
        return Objects.hash(id, name);
    }
}

public class BadPractice {
    private final String id;
    private final String name;
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof BadPractice that)) return false;
        return Objects.equals(this.id, that.id);
    }
    
    @Override
    public int hashCode() {
        // ❌ НЕПРАВИЛЬНО: hashCode зависит от name,
        // но equals не проверяет name
        return Objects.hash(id, name);
    }
}

String как пример иммутабельного объекта

public final class StringExample {
    public static void main(String[] args) {
        String str = "Hello";
        int hash1 = str.hashCode();
        
        // Пытаемся "изменить"
        String str2 = str.concat(" World");
        
        // str не изменился - создалась новая строка
        int hash2 = str.hashCode();
        System.out.println(hash1 == hash2);  // true
        
        // Это нормально использовать как ключ HashMap
        HashMap<String, String> map = new HashMap<>();
        map.put("key", "value");
        System.out.println(map.get("key"));  // "value" - работает!
    }
}

Кэширование hashCode() для оптимизации

public final class CachedHashCode {
    private final String email;
    private final int age;
    private final int hash;  // Кэшируем hashCode
    
    public CachedHashCode(String email, int age) {
        this.email = Objects.requireNonNull(email);
        this.age = age;
        this.hash = Objects.hash(email, age);  // Вычисляем один раз
    }
    
    @Override
    public int hashCode() {
        return hash;  // Просто возвращаем кэшированное значение
    }
}

Почему это работает:

• Объект иммутабельный → состояние не меняется
• hashCode вычисляется один раз в конструкторе
• Каждый вызов hashCode() возвращает то же значение
• String использует точно такой же подход

Практическое правило

// ✅ ПРАВИЛО: Иммутабельность + правильная реализация equals/hashCode
public final class User {
    private final String email;
    private final int id;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User user)) return false;
        return id == user.id && Objects.equals(email, user.email);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id, email);
    }
    
    // hashCode этого объекта остается неизменным
    // Можно безопасно использовать как ключ в HashMap, HashSet
}

// ❌ ОПАСНОСТЬ: Мутабельный объект
public class MutableData {
    public String email;  // public - может измениться
    public int id;
    
    @Override
    public int hashCode() {
        return Objects.hash(id, email);
    }
}

Итоговый ответ

Для иммутабельных объектов:

• ✅ hashCode НИКОГДА не меняется
• ✅ Это гарантируется тем, что поля не могут измениться
• ✅ Безопасны как ключи HashMap/HashSet
• ✅ Кэширование hashCode() - дополнительная оптимизация

Для мутабельных объектов:

• ❌ hashCode может измениться если изменяются поля
• ❌ Это нарушает контракт HashMap
• ❌ Данные могут быть потеряны
• ❌ НИКОГДА не используй мутабельные объекты как ключи

Главное правило: Иммутабельность и стабильность hashCode() - это не просто best practice, это гарантия корректности работы коллекций в Java.