Как устроен equals?

Как устроен equals

equals() — это фундаментальный метод в Java для сравнения объектов по содержанию (значению), а не по ссылке. Правильная реализация equals() критична для корректной работы коллекций, HashMap, HashSet и логики приложения.

Определение в Object

Все классы наследуют equals() из java.lang.Object:

// Базовая реализация в Object
public boolean equals(Object obj) {
    return this == obj;  // По умолчанию сравнивает ссылки
}

Это означает, что по умолчанию equals() работает как == — сравнивает ссылки, а не содержимое.

Проблема без переопределения equals()

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class EqualsExample {
    public static void main(String[] args) {
        Person p1 = new Person("John", 30);
        Person p2 = new Person("John", 30);  // Те же данные
        
        // БЕЗ переопределённого equals()
        System.out.println(p1.equals(p2));  // false (разные ссылки)
        System.out.println(p1 == p2);       // false (разные объекты)
        
        // В коллекциях это приводит к проблемам
        Set<Person> people = new HashSet<>();
        people.add(p1);
        people.add(p2);  // Добавится как НОВЫЙ объект
        System.out.println(people.size());  // 2 (хотя должна быть 1)
    }
}

Контракт equals(): правила реализации

Оффициальный контракт из JavaDoc Object.equals():

public class EqualsContract {
    // Контракт equals() имеет 5 требований:
    
    // 1. REFLEXIVE (Рефлексивность)
    // x.equals(x) ДОЛЖНА быть true
    public boolean reflexive(Object x) {
        return x.equals(x);  // Всегда true
    }
    
    // 2. SYMMETRIC (Симметричность)
    // Если x.equals(y), то y.equals(x)
    public boolean symmetric(Object x, Object y) {
        return x.equals(y) == y.equals(x);
    }
    
    // 3. TRANSITIVE (Транзитивность)
    // Если x.equals(y) и y.equals(z), то x.equals(z)
    public boolean transitive(Object x, Object y, Object z) {
        if (!x.equals(y) || !y.equals(z)) return true;
        return x.equals(z);  // Должно быть true
    }
    
    // 4. CONSISTENT (Последовательность)
    // Многократные вызовы дают одинаковый результат
    public boolean consistent(Object x, Object y) {
        boolean result1 = x.equals(y);
        boolean result2 = x.equals(y);
        return result1 == result2;  // Всегда true
    }
    
    // 5. NULL
    // x.equals(null) ДОЛЖНА быть false
    public boolean nullHandling(Object x) {
        return !x.equals(null);  // false
    }
}

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

Базовый подход:

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object obj) {
        // 1. Проверка на null
        if (obj == null) {
            return false;
        }
        
        // 2. Проверка на одинаковый тип
        if (!(obj instanceof Person)) {
            return false;
        }
        
        // 3. Кастим и сравниваем поля
        Person other = (Person) obj;
        return this.name.equals(other.name) &&
               this.age == other.age;
    }
}

// Тестирование
public class EqualsTest {
    public static void main(String[] args) {
        Person p1 = new Person("John", 30);
        Person p2 = new Person("John", 30);
        Person p3 = new Person("Jane", 25);
        
        System.out.println(p1.equals(p2));  // true (одинаковые данные)
        System.out.println(p1.equals(p3));  // false (разные данные)
        System.out.println(p1.equals(null));  // false
        System.out.println(p1.equals("John"));  // false (разные типы)
    }
}

Связь equals() и hashCode()

КРИТИЧЕСКИ ВАЖНО: если переопределяешь equals(), ОБЯЗАТЕЛЬНО переопределяй и hashCode()!

public class PersonWithHash {
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object obj) {
        if (obj == null || !(obj instanceof PersonWithHash)) return false;
        PersonWithHash other = (PersonWithHash) obj;
        return this.name.equals(other.name) && this.age == other.age;
    }
    
    @Override
    public int hashCode() {
        // hashCode() должен быть согласован с equals()
        // Если two objects equal, их hashCode ДОЛЖНЫ быть одинаковыми
        return Objects.hash(name, age);
    }
}

// ПРИМЕР ПРОБЛЕМЫ без hashCode()
public class HashCodeProblem {
    public static void main(String[] args) {
        PersonWithHash p1 = new PersonWithHash("John", 30);
        PersonWithHash p2 = new PersonWithHash("John", 30);
        
        System.out.println(p1.equals(p2));  // true (equals работает)
        
        // Но в HashMap это приводит к проблеме
        HashMap<PersonWithHash, String> map = new HashMap<>();
        map.put(p1, "Person 1");
        
        // p2 имеет другой hashCode, поэтому не найдётся в map
        System.out.println(map.get(p2));  // null (ПРОБЛЕМА!)
        // Хотя p1.equals(p2) == true
    }
}

Правильная реализация с hashCode()

public final class User {
    private final String email;
    private final String name;
    private final int age;
    
    public User(String email, String name, int age) {
        this.email = email;
        this.name = name;
        this.age = 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 &&
               email.equals(user.email) &&
               name.equals(user.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(email, name, age);
    }
    
    @Override
    public String toString() {
        return "User{" +
               "email='" + email + '\'' +
               ", name='" + name + '\'' +
               ", age=" + age +
               '}';
    }
}

// Использование
public class UserTest {
    public static void main(String[] args) {
        User u1 = new User("john@mail.com", "John", 30);
        User u2 = new User("john@mail.com", "John", 30);
        
        System.out.println(u1.equals(u2));  // true
        System.out.println(u1.hashCode() == u2.hashCode());  // true
        
        // Теперь работает в HashMap
        HashMap<User, String> map = new HashMap<>();
        map.put(u1, "Developer");
        System.out.println(map.get(u2));  // "Developer" (РАБОТАЕТ!)
        
        // И в HashSet
        Set<User> users = new HashSet<>();
        users.add(u1);
        users.add(u2);
        System.out.println(users.size());  // 1 (один объект, как и ожидается)
    }
}

Частые ошибки

public class EqualsMistakes {
    
    // ОШИБКА 1: Не проверка null
    class BadEquals {
        private String name;
        public boolean equals(Object obj) {
            Person p = (Person) obj;  // NullPointerException если obj == null
            return name.equals(p.name);
        }
    }
    
    // ОШИБКА 2: Не проверка типа
    class BadEquals2 {
        private String name;
        public boolean equals(Object obj) {
            Person p = (Person) obj;  // ClassCastException если другой тип
            return name.equals(p.name);
        }
    }
    
    // ОШИБКА 3: Только hashCode, без equals
    class BadHash {
        private String name;
        public int hashCode() {
            return Objects.hash(name);
        }
        // equals не переопределён — будет сравниваться по ссылке!
    }
    
    // ОШИБКА 4: Нарушение контракта
    class SymmetryViolation {
        public static class MutableList extends java.util.ArrayList<String> {
            public boolean equals(Object obj) {
                // Нарушает симметричность со своим суперклассом
                // mutableList.equals(arrayList) может быть true
                // но arrayList.equals(mutableList) false
            }
        }
    }
}

Lombok и equals()

Ломбок автоматически генерирует equals() и hashCode():

import lombok.EqualsAndHashCode;

@EqualsAndHashCode
public class PersonLombok {
    private String name;
    private int age;
    
    // equals() и hashCode() генерируются автоматически
    // Эквивалентно ручной реализации выше
}

// С исключениями
@EqualsAndHashCode(exclude = "id")
public class Entity {
    private String id;  // Не будет участвовать в equals/hashCode
    private String name;
}

equals() vs compareTo()

public class EqualsVsCompareTo {
    // equals() — для проверки эквивалентности
    // compareTo() — для определения порядка
    
    public static void main(String[] args) {
        Integer a = 5;
        Integer b = 5;
        
        // equals() для эквивалентности
        System.out.println(a.equals(b));  // true (значения равны)
        
        // compareTo() для сортировки
        System.out.println(a.compareTo(b));  // 0 (a == b)
        
        Integer c = 10;
        System.out.println(a.compareTo(c));  // -1 (a < c)
    }
}

Таблица сравнения

Практические рекомендации

public class BestPractices {
    // 1. Всегда переопределяй equals() и hashCode() вместе
    // 2. Проверяй null в начале
    // 3. Проверяй тип объекта
    // 4. Используй Objects.equals() для null-safe сравнения полей
    // 5. Документируй контракт в JavaDoc
    // 6. Тестируй reflexive, symmetric, transitive, consistent
    // 7. Используй IDE или Lombok для генерации
}

Правильная реализация equals() — это ключ к корректной работе Java приложения, особенно при использовании коллекций.