Что будет возвращать equals при многократном использовании с одними и теми же объектами?

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

equals() при многократном использовании с одними и теми же объектами ДОЛЖНА возвращать ОДИНАКОВЫЙ результат.

Это не просто особенность, это обязательный контракт метода equals(), определённый в Java спецификации и документации Object класса.

Контракт equals()

Если заглянуть в JavaDoc Object.equals():

public boolean equals(Object obj) {
    // Возвращает true если и только если x и y ссылаются на один объект
    return (this == obj);
}

Контракт состоит из 5 свойств:

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

Для любого ненулевого объекта x:

x.equals(x) // ВСЕГДА вернёт true

Object obj = "Hello";
assert obj.equals(obj) == true;  // Всегда true
assert obj.equals(obj) == true;  // Снова true
assert obj.equals(obj) == true;  // И снова true

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

Для любых ненулевых объектов x и y:

if (x.equals(y)) {
    // Тогда гарантированно:
    assert y.equals(x) == true;
}

String a = "Hello";
String b = "Hello";

assert a.equals(b) == true;   // true
assert b.equals(a) == true;   // true — гарантировано!

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

Для любых ненулевых объектов x, y, z:

if (x.equals(y) && y.equals(z)) {
    // Тогда гарантированно:
    assert x.equals(z) == true;
}

Integer a = 5;
Integer b = 5;
Integer c = 5;

assert a.equals(b) == true;   // true
assert b.equals(c) == true;   // true
assert a.equals(c) == true;   // true — гарантировано!

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

При многократном вызове с одними и теми же объектами, результат всегда одинаковый:

String a = "Hello";
String b = "Hello";

// Эти вызовы можно делать бесконечное количество раз
assert a.equals(b) == true;   // true
assert a.equals(b) == true;   // true
assert a.equals(b) == true;   // true
// Результат НИКОГДА не изменится (если объекты immutable)

Это то, что ты спрашиваешь! equals() должна быть детерминистичной, базироваться только на данных объекта и не зависеть от времени, последовательности вызовов и других внешних факторов.

5. Nullability

Удовлетворение с null'ом:

Object x = "Hello";
assert x.equals(null) == false;  // Никогда не null.equals(...)

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

public class User {
    private final String email;
    private final String name;
    private int age;  // Mutable!
    
    public User(String email, String name) {
        this.email = email;
        this.name = name;
    }
    
    // НЕПРАВИЛЬНАЯ реализация
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof User)) return false;
        User other = (User) obj;
        
        // ПРОБЛЕМА 1: Используем mutable поле!
        return this.age == other.age;  // ОПА! Результат может измениться
        
        // ПРОБЛЕМА 2: Используем random!
        // return Math.random() > 0.5;  // НИКОГДА так не делай!
    }
}

User user1 = new User("john@mail.com", "John");
User user2 = new User("john@mail.com", "John");

assert user1.equals(user2) == true;
user1.setAge(25);
// Теперь результат может быть false! НАРУШЕНИЕ КОНТРАКТА!

ПРАВИЛЬНАЯ реализация

public class User {
    private final String email;  // Используем только immutable поля!
    private final String name;
    private int age;  // Mutable — НЕ используем в equals()
    
    @Override
    public boolean equals(Object obj) {
        if (obj == null) return false;                    // Null check
        if (!(obj instanceof User)) return false;         // Type check
        if (this == obj) return true;                     // Identity check (оптимизация)
        
        User other = (User) obj;
        return this.email.equals(other.email) &&          // Только immutable поля!
               this.name.equals(other.name);
    }
    
    @Override
    public int hashCode() {
        // ВАЖНО! hashCode() должен быть согласован с equals()
        return Objects.hash(email, name);
    }
}

// Теперь это работает правильно
User user1 = new User("john@mail.com", "John");
User user2 = new User("john@mail.com", "John");

assert user1.equals(user2) == true;   // true
assert user2.equals(user1) == true;   // true (симметричность)
user1.setAge(25);
assert user1.equals(user2) == true;   // Всё ещё true! (консистентность)

Частая ошибка: использование mutable полей

public class Rectangle {
    private int width;  // Mutable
    private int height; // Mutable
    
    // НЕПРАВИЛЬНО!
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Rectangle)) return false;
        Rectangle other = (Rectangle) obj;
        return this.width == other.width && this.height == other.height;
    }
}

Rectangle rect1 = new Rectangle(5, 10);
Rectangle rect2 = new Rectangle(5, 10);

assert rect1.equals(rect2) == true;
rect1.setWidth(10);
assert rect1.equals(rect2) == false;  // Изменился результат!

// Если используешь эти объекты как ключи в HashMap:
Map<Rectangle, String> map = new HashMap<>();
map.put(rect1, "original");

rect1.setWidth(10);  // Изменили объект после добавления!
map.get(rect1);      // null! Не найдёт!
// Потому что hashCode() поменялся, а объект всё ещё находится в старом bucket'е

Проблема с equals() если нарушить контракт

public class BuggyClass {
    private List<Integer> data = new ArrayList<>();
    
    // НЕПРАВИЛЬНО: зависит от внешнего состояния
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof BuggyClass)) return false;
        BuggyClass other = (BuggyClass) obj;
        // Зависит от текущего размера list'а!
        return this.data.size() == other.data.size();
    }
}

BuggyClass obj1 = new BuggyClass();
BuggyClass obj2 = new BuggyClass();

assert obj1.equals(obj2) == true;  // true (оба пустые)

obj1.getData().add(1);
assert obj1.equals(obj2) == false;  // false
assert obj1.equals(obj2) == false;  // false (консистентно, но...)

// А теперь добавим в объект 2
obj2.getData().add(1);
assert obj1.equals(obj2) == true;   // true (снова!)

// Это ОЧЕНЬ плохо для HashMap/HashSet:
Set<BuggyClass> set = new HashSet<>();
set.add(obj1);
obj1.getData().add(2);  // Изменили после добавления!
set.contains(obj1);     // false! Объект "потерян" в set'е!

Best Practice: Использовать Objects.equals()

public class User {
    private final String email;
    private final String name;
    private final LocalDate birthDate;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof User)) return false;
        
        User other = (User) obj;
        return Objects.equals(this.email, other.email) &&        // null-safe!
               Objects.equals(this.name, other.name) &&
               Objects.equals(this.birthDate, other.birthDate);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(email, name, birthDate);
    }
}

Тестирование equals() контракта

public class UserTest {
    
    @Test
    void testEqualsReflexive() {
        User user = new User("john@mail.com", "John");
        assert user.equals(user) == true;  // x.equals(x) == true
    }
    
    @Test
    void testEqualsSymmetric() {
        User user1 = new User("john@mail.com", "John");
        User user2 = new User("john@mail.com", "John");
        
        assert user1.equals(user2) == true;
        assert user2.equals(user1) == true;  // Симметричность
    }
    
    @Test
    void testEqualsConsistent() {
        User user1 = new User("john@mail.com", "John");
        User user2 = new User("john@mail.com", "John");
        
        // Вызываем 100 раз
        for (int i = 0; i < 100; i++) {
            assert user1.equals(user2) == true;
        }
    }
    
    @Test
    void testEqualsNull() {
        User user = new User("john@mail.com", "John");
        assert user.equals(null) == false;
    }
}

Summary

equals() при многократном использовании с одними и теми же объектами вернёт ОДИНАКОВЫЙ результат. Это:

1. Обязательно по контракту Java
2. Критично для HashMap, HashSet, Collections — все они полагаются на стабильность equals()
3. Достигается: только используя immutable поля или поля, которые не меняются после создания
4. Нарушение ведёт к жутким багам — потеря объектов в HashMap'ах, бесконечные циклы и т.д.

Лучшее правило: используй только private final (immutable) поля в equals().