Какими свойствами должен обладать equals

Свойства метода equals

Метод equals() в Java должен удовлетворять пяти математическим свойствам, определённым в JavaDoc Object.equals(). Эти свойства гарантируют правильное сравнение объектов и корректную работу с коллекциями.

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

Объект должен быть равен самому себе: x.equals(x) == true

String str = "Hello";
assert str.equals(str) == true;  // ✅ Правильно

Это должно быть верно для любого ненулевого объекта.

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

Если x.equals(y) == true, то и y.equals(x) == true

Другими словами, результат не зависит от порядка сравнения.

String a = "Test";
String b = "Test";

assert a.equals(b) == true;
assert b.equals(a) == true;  // ✅ Симметрично

❌ Пример нарушения:

class CaseInsensitiveString {
    private String s;
    
    @Override
    public boolean equals(Object o) {
        if (o instanceof CaseInsensitiveString) {
            return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
        }
        if (o instanceof String) {
            return s.equalsIgnoreCase((String) o);  // ❌ Проблема!
        }
        return false;
    }
}

CaseInsensitiveString cis = new CaseInsensitiveString("ABC");
String str = "abc";

assert cis.equals(str) == true;   // ✅ true
assert str.equals(cis) == false;  // ❌ false — нарушение симметричности!

✅ Правильное решение:

public boolean equals(Object o) {
    // Сравниваем только с объектами того же типа
    if (!(o instanceof CaseInsensitiveString)) {
        return false;
    }
    return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
}

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

Если x.equals(y) == true и y.equals(z) == true, то x.equals(z) == true

Integer x = 1;
Integer y = 1;
Integer z = 1;

assert x.equals(y) == true;
assert y.equals(z) == true;
assert x.equals(z) == true;  // ✅ Транзитивно

❌ Пример нарушения при наследовании:

class Point {
    protected int x, y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Point)) return false;
        return x == ((Point) o).x && y == ((Point) o).y;
    }
}

class ColorPoint extends Point {
    private String color;
    
    public ColorPoint(int x, int y, String color) {
        super(x, y);
        this.color = color;
    }
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ColorPoint)) return false;  // ❌ Проблема!
        return super.equals(o) && ((ColorPoint) o).color.equals(color);
    }
}

Point p1 = new Point(1, 1);
ColorPoint cp1 = new ColorPoint(1, 1, "red");
ColorPoint cp2 = new ColorPoint(1, 1, "red");

assert p1.equals(cp1) == true;    // ✅ true
assert cp1.equals(cp2) == true;    // ✅ true
assert p1.equals(cp2) == true;     // ❌ false — нарушение транзитивности!

✅ Решение: композиция вместо наследования:

class ColorPoint {
    private Point point;
    private String color;
    
    public ColorPoint(int x, int y, String color) {
        this.point = new Point(x, y);
        this.color = color;
    }
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ColorPoint)) return false;
        ColorPoint cp = (ColorPoint) o;
        return point.equals(cp.point) && color.equals(cp.color);
    }
}

4. Консистентность (Consistency)

Множественные вызовы x.equals(y) должны возвращать одинаковый результат, если объекты не были изменены.

String a = "Test";
String b = "Test";

// Все вызовы вернут true
assert a.equals(b) == true;
assert a.equals(b) == true;
assert a.equals(b) == true;

❌ Пример нарушения:

class BadClass {
    private java.util.Date date = new java.util.Date();
    
    @Override
    public boolean equals(Object o) {
        // Зависит от текущего времени — нарушает консистентность!
        return date.getTime() % 2 == 0;
    }
}

5. Равенство с null

x.equals(null) должно всегда возвращать false (никогда не выбрасывать исключение)

String str = "Test";
assert str.equals(null) == false;  // ✅ Правильно

❌ Неправильно:

public boolean equals(Object o) {
    return this.value.equals(o.value);  // ❌ NullPointerException, если o == null!
}

✅ Правильно:

public boolean equals(Object o) {
    if (o == null) return false;  // или
    if (!(o instanceof MyClass)) return false;
    // ...
}

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

public class User {
    private Long id;
    private String name;
    private String email;
    
    @Override
    public boolean equals(Object o) {
        // 1. Проверка на идентичность
        if (this == o) return true;
        
        // 2. Проверка на null и тип
        if (o == null || !(o instanceof User)) return false;
        
        // 3. Приведение типа
        User user = (User) o;
        
        // 4. Сравнение полей
        return Objects.equals(id, user.id) &&
               Objects.equals(name, user.name) &&
               Objects.equals(email, user.email);
    }
    
    // Если переопределяешь equals, ВСЕГДА переопредели hashCode!
    @Override
    public int hashCode() {
        return Objects.hash(id, name, email);
    }
}

Использование Objects.equals()

В Java 7+ используй Objects.equals() вместо ручного сравнения — это безопаснее для null:

// Небезопасно
if (a.equals(b)) { }  // NullPointerException, если a == null

// Безопасно
if (Objects.equals(a, b)) { }  // Обработает null

Связь с hashCode()

Критически важное правило: если переопределяешь equals(), ВСЕГДА переопредели hashCode() с соблюдением:

• Если a.equals(b), то a.hashCode() == b.hashCode()
• Обратное не обязательно, но желательно

Иначе объекты не будут работать корректно в HashSet, HashMap и других хеш-коллекциях.

HashMap<User, String> map = new HashMap<>();
User user1 = new User(1L, "Alice", "alice@test.com");
User user2 = new User(1L, "Alice", "alice@test.com");

// Если не переопределить hashCode:
map.put(user1, "value1");
map.put(user2, "value2");  // ❌ Добавит второй объект вместо замены!

// С правильным hashCode:
map.put(user1, "value1");
map.put(user2, "value2");  // ✅ Заменит значение
assert map.size() == 1;

Эти пять свойств гарантируют, что equals() работает предсказуемо и безопасно во всех ситуациях.