Какие знаешь условия совместной работы hashCode и equals?

Условия совместной работы hashCode() и equals() в Java

Методы hashCode() и equals() — это фундаментальная пара контрактов в Java, которые должны работать согласованно. Они критически важны при использовании объектов в хэш-коллекциях (HashMap, HashSet, Hashtable).

Контракт между hashCode() и equals()

Официальный контракт из документации Java:

Основное правило: если два объекта равны по equals(), то их hashCode() ОБЯЗАТЕЛЬНО должен быть одинаковым.

Если a.equals(b) == true,  то a.hashCode() == b.hashCode() ВСЕГДА

Обратное правило НЕ гарантируется: разные объекты могут иметь одинаковый hashCode (это называется коллизия).

Четыре условия контракта

1. Рефлексивность equals()

// Объект всегда равен самому себе
Object obj = new Person("John", 30);
assert obj.equals(obj) == true;

2. Симметричность equals()

// Если a.equals(b), то b.equals(a)
Person p1 = new Person("John", 30);
Person p2 = new Person("John", 30);
assert p1.equals(p2) == p2.equals(p1);

3. Транзитивность equals()

// Если a.equals(b) и b.equals(c), то a.equals(c)
Person p1 = new Person("John", 30);
Person p2 = new Person("John", 30);
Person p3 = new Person("John", 30);
assert p1.equals(p2) && p2.equals(p3) && p1.equals(p3);

4. Согласованность с hashCode()

// a.equals(b) => a.hashCode() == b.hashCode()
Person p1 = new Person("John", 30);
Person p2 = new Person("John", 30);
if (p1.equals(p2)) {
    assert p1.hashCode() == p2.hashCode(); // ОБЯЗАТЕЛЬНО!
}

Примеры нарушения контракта

// ❌ НЕПРАВИЛЬНО: hashCode не согласован с equals
class BadPerson {
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof BadPerson)) return false;
        BadPerson p = (BadPerson) o;
        return name.equals(p.name) && age == p.age;
    }
    
    @Override
    public int hashCode() {
        return 42; // ВСЕГДА одно и то же число - коллизия!
    }
}

// Проблема в действии:
BadPerson p1 = new BadPerson("John", 30);
BadPerson p2 = new BadPerson("John", 30);

Set<BadPerson> set = new HashSet<>();
set.add(p1);
set.add(p2);

assert set.size() == 1; // Ожидаем 1 (равные объекты)
// Но если hashCode не согласован, результаты непредсказуемы!

Map<BadPerson, String> map = new HashMap<>();
map.put(p1, "value1");
String value = map.get(p2); // Может быть null, хотя p1.equals(p2) == true!

Правильная реализация

// ✅ ПРАВИЛЬНО: hashCode согласован с equals
class GoodPerson {
    private String name;
    private int age;
    
    public GoodPerson(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        GoodPerson person = (GoodPerson) o;
        return age == person.age && name.equals(person.name);
    }
    
    @Override
    public int hashCode() {
        // Используем те же поля, что и в equals!
        return Objects.hash(name, age);
    }
}

// Работает правильно:
GoodPerson p1 = new GoodPerson("John", 30);
GoodPerson p2 = new GoodPerson("John", 30);

Set<GoodPerson> set = new HashSet<>();
set.add(p1);
set.add(p2);
assert set.size() == 1; // ✓ Правильно!

Map<GoodPerson, String> map = new HashMap<>();
map.put(p1, "value1");
assert map.get(p2).equals("value1"); // ✓ Работает!

Как hashCode используется в HashMap

Map<Person, String> map = new HashMap<>();
Person p1 = new Person("Alice", 25);

// 1. При добавлении: вычисляется hashCode
map.put(p1, "Engineer");
// hashCode() -> 12345
// Объект кладётся в бакет #12345

// 2. При поиске: сначала проверяется hashCode
Person p2 = new Person("Alice", 25);
String value = map.get(p2);
// hashCode() -> 12345 (если equals согласован)
// Идём в бакет #12345
// Далее используем equals() для точного совпадения
// ✓ Находим значение!

// Если hashCode() не согласован:
// hashCode() -> 67890 (другое значение)
// Идём в бакет #67890
// Там ничего нет -> null (неправильно!)

Правило: какие поля учитывать в equals и hashCode

Правило: В equals и hashCode должны входить ОДНИ И ТЕ ЖЕ поля!

class Employee {
    private String name;        // Включаем
    private int employeeId;    // Включаем
    private Date hireDate;     // Включаем
    private transient int temporary; // НЕ включаем (временный)
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Employee)) return false;
        Employee e = (Employee) o;
        return name.equals(e.name) &&
               employeeId == e.employeeId &&
               hireDate.equals(e.hireDate);
        // temporary НЕ сравниваем!
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, employeeId, hireDate);
        // ТЕ ЖЕ поля, что в equals!
    }
}

Использование @Override аннотации

// ✅ Всегда используй @Override
class Person {
    @Override
    public boolean equals(Object o) {
        // ...
    }
    
    @Override
    public int hashCode() {
        // ...
    }
}
// IDE автоматически предупредит об ошибках

IDE автоматическая генерация

В IntelliJ IDEA: Ctrl+N (Generate) → выбери equals() и hashCode()

Это гарантирует соответствие контракту и экономит время.

Последствия нарушения контракта

• HashMap/HashSet работают неправильно — не находится существующий ключ
• Потеря данных — объекты теряются в коллекции
• Трудноуловимые баги — поведение зависит от реализации хеш-функции
• Нарушение инвариантов — map.get(key) может вернуть null, хотя key есть в map

Поэтому контракт между hashCode() и equals() — это не рекомендация, а ОБЯЗАТЕЛЬСТВО для корректной работы Java коллекций.