Охарактеризуй принципы контракта equals в Java

Контракт метода equals() в Java

Метод equals() является одним из ключевых методов класса Object. Его корректная реализация критична для правильной работы коллекций и логики сравнения объектов.

Пять принципов контракта equals

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

Для любого ненулевого значения x: x.equals(x) должен возвращать true

String str = "hello";
assert str.equals(str);  // true

Это базовое требование: объект должен быть равен самому себе. Нарушение этого принципа приводит к проблемам при работе с HashSet и HashMap.

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

Для любых x и y: если x.equals(y), то y.equals(x)

String a = "Java";
String b = new String("Java");
assert a.equals(b);  // true
assert b.equals(a);  // true (симметрично)

Ошибка в реализации:

class CaseInsensitiveString {
    private final 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("Polish");
String s = "polish";
assert cis.equals(s);  // true
assert s.equals(cis);  // false - нарушение!

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

Для любых x, y, z: если x.equals(y) и y.equals(z), то x.equals(z)

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
assert a.equals(b);  // true

BigDecimal c = new BigDecimal("1.0");
assert a.equals(c);  // true
assert b.equals(c);  // true - транзитивно

Ошибка при наследовании:

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

class ColorPoint extends Point {
    private Color color;
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ColorPoint)) return false;
        return super.equals(o) && ((ColorPoint) o).color == color;
    }
}

ColorPoint p1 = new ColorPoint(1, 2, RED);
Point p2 = new Point(1, 2);
ColorPoint p3 = new ColorPoint(1, 2, BLUE);

assert p1.equals(p2);  // true
assert p2.equals(p3);  // true
assert p1.equals(p3);  // false - нарушение транзитивности!

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

Для любых x и y: повторяющиеся вызовы x.equals(y) возвращают одинаковый результат (если объекты не изменялись)

String a = "hello";
String b = "hello";
assert a.equals(b) == a.equals(b);  // всегда одинаково

Ошибка:

class BadClass {
    private Random rand = new Random();
    
    @Override
    public boolean equals(Object o) {
        return rand.nextBoolean();  // ❌ Нарушает консистентность!
    }
}

5. Сравнение с null

Для любого ненулевого x: x.equals(null) должен возвращать false (никогда true)

String str = "hello";
assert !str.equals(null);  // всегда false

Лучшая практика: реализация equals

final class Person {
    private final String name;
    private final int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return age == person.age &&
               Objects.equals(name, person.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Важное правило: hashCode() и equals()

Если переопределяешь equals(), обязательно переопредели hashCode():

Object a = new Object();
Object b = new Object();

if (a.equals(b)) {
    assert a.hashCode() == b.hashCode();  // Это ТРЕБОВАНИЕ контракта!
}

Если нарушить - коллекции на основе Hash будут работать неправильно:

Set<Person> set = new HashSet<>();
Person p1 = new Person("John", 30);
Person p2 = new Person("John", 30);

set.add(p1);
if (p1.equals(p2) && p1.hashCode() != p2.hashCode()) {
    set.add(p2);  // Оба объекта будут в set, хотя equals() говорит они равны!
}

Заключение

Пять принципов equals():

1. Рефлексивность - объект равен себе
2. Симметричность - если a равно b, то b равно a
3. Транзитивность - если a равно b и b равно c, то a равно c
4. Консистентность - повторяющиеся вызовы дают одинаковый результат
5. Сравнение с null - никогда не равно null

Используй IDE для генерации equals() и hashCode(), это безопаснее ручной реализации.