Всегда ли нужно переопределять equals?

Всегда ли нужно переопределять equals()?

Ответ: Нет, не всегда. Это важный вопрос о проектировании. Нужно понимать когда это критично.

1. Когда НЕ нужно переопределять equals()

Scenario 1: Значения по умолчанию достаточны

public class DatabaseConnection {
    private String url;
    private int poolSize;
    
    // НЕ переопределяем equals()
    // Используем default: сравнение по ссылке (identity)
}

public void example() {
    DatabaseConnection conn1 = new DatabaseConnection();
    DatabaseConnection conn2 = new DatabaseConnection();
    
    // conn1.equals(conn2) == false (разные объекты)
    // Это правильно! Каждое соединение уникально
    
    DatabaseConnection conn3 = conn1;
    // conn1.equals(conn3) == true (одна ссылка)
}

Когда использовать: для объектов, которые представляют сущности (Entity objects).

Scenario 2: Объект используется как ключ в Map

public class User {
    private Long id;
    private String name;
    
    // ТОЛЬКО если используется как ключ в Map, переопределяем equals()
    // и hashCode()
}

public void mapUsage() {
    Map<User, String> map = new HashMap<>();
    User user1 = new User(1L, "John");
    User user2 = new User(1L, "John");
    
    map.put(user1, "Developer");
    
    // Без переопределения equals(): map.get(user2) вернёт null
    // С переопределением: map.get(user2) вернёт "Developer"
}

2. Когда НУЖНО переопределять equals()

Scenario 1: Value Objects (DTO, VO)

// Value Object — представляет значение, не сущность
public final class Money {
    private final BigDecimal amount;
    private final String currency;
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Money)) return false;
        Money other = (Money) obj;
        return amount.equals(other.amount) && 
               currency.equals(other.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
}

public void example() {
    Money m1 = new Money(100, "USD");
    Money m2 = new Money(100, "USD");
    
    assert m1.equals(m2);  // true — одинаковые значения
}

Scenario 2: Использование в коллекциях (List, Set)

public class Email {
    private final String address;
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Email)) return false;
        Email other = (Email) obj;
        return address.equalsIgnoreCase(other.address);
    }
    
    @Override
    public int hashCode() {
        return address.toLowerCase().hashCode();
    }
}

public void collectionUsage() {
    Set<Email> emails = new HashSet<>();
    emails.add(new Email("john@example.com"));
    emails.add(new Email("JOHN@EXAMPLE.COM"));
    
    // С переопределением equals: size = 1 (дубликат отрезан)
    // Без переопределения: size = 2 (разные объекты)
}

Scenario 3: Business Logic equality

public class Order {
    private Long id;
    private LocalDateTime createdAt;
    private BigDecimal totalAmount;
    
    @Override
    public boolean equals(Object obj) {
        // Два заказа "равны" если имеют одинаковый id
        if (!(obj instanceof Order)) return false;
        Order other = (Order) obj;
        return id != null && id.equals(other.id);
    }
    
    @Override
    public int hashCode() {
        return id != null ? id.hashCode() : 0;
    }
}

public void businessLogic() {
    Order order1 = new Order(1L, LocalDateTime.now(), new BigDecimal(100));
    Order order2 = new Order(1L, LocalDateTime.now().minusHours(1), new BigDecimal(200));
    
    // order1.equals(order2) == true (одинаковый id)
    // Хотя createdAt и totalAmount отличаются
}

3. Таблица: когда переопределять equals()

4. Типичные ошибки

Ошибка 1: забыть hashCode()

public class BadExample {
    private String id;
    
    @Override
    public boolean equals(Object obj) {  // Переопределили
        if (!(obj instanceof BadExample)) return false;
        return id.equals(((BadExample) obj).id);
    }
    // ЗАБЫЛИ hashCode()!
}

public void problem() {
    Set<BadExample> set = new HashSet<>();
    BadExample obj1 = new BadExample("same");
    BadExample obj2 = new BadExample("same");
    
    set.add(obj1);
    set.add(obj2);
    
    // obj1.equals(obj2) == true
    // Но set.size() == 2 (дубликат не отрезан!)
    // Потому что hashCode() разные
}

Ошибка 2: использовать mutable field в equals()

public class MutableUser {
    private String id;
    private String name;  // Может меняться
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof MutableUser)) return false;
        MutableUser other = (MutableUser) obj;
        return id.equals(other.id) && name.equals(other.name);
    }
    
    public void setName(String name) { this.name = name; }
}

public void problem() {
    Set<MutableUser> set = new HashSet<>();
    MutableUser user = new MutableUser("1", "John");
    
    set.add(user);
    user.setName("Jane");  // Изменили name
    
    // user.equals() вернёт другой результат
    // Set сломан!
    boolean found = set.contains(user);  // Может быть false!
}

5. Когда NOT переопределять, но хочется сравнить

// Entity с id
public class User {
    @Id
    private Long id;
    private String name;
    
    // НЕ переопределяем equals() (по умолчанию: identity)
    
    // Но добавляем метод для сравнения по значению
    public boolean hasSameId(User other) {
        return this.id != null && this.id.equals(other.id);
    }
}

public void example() {
    User user1 = userRepository.findById(1L);
    User user2 = userRepository.findById(1L);
    
    assert !user1.equals(user2);  // false (разные объекты)
    assert user1.hasSameId(user2);  // true (одинаковый id)
}

6. Правила переопределения (напоминание)

public final class Property {
    private final String name;
    private final Object value;
    
    @Override
    public boolean equals(Object obj) {
        // 1. Проверка instanceof
        if (!(obj instanceof Property)) return false;
        
        Property other = (Property) obj;
        
        // 2. Сравнение полей
        return Objects.equals(this.name, other.name) &&
               Objects.equals(this.value, other.value);
    }
    
    @Override
    public int hashCode() {
        // 3. Консистентность с equals()
        return Objects.hash(name, value);
    }
}

7. Реальный пример

// Entity — НЕ переопределяем
@Entity
public class User {
    @Id
    private Long id;
    private String email;
}

// DTO — ПЕРЕОПРЕДЕЛЯЕМ
@Data  // Lombok генерирует equals/hashCode
public class UserDTO {
    private Long id;
    private String email;
}

// Value Object — ПЕРЕОПРЕДЕЛЯЕМ
public class EmailAddress {
    private final String value;
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof EmailAddress)) return false;
        return value.equalsIgnoreCase(((EmailAddress) obj).value);
    }
    
    @Override
    public int hashCode() {
        return value.toLowerCase().hashCode();
    }
}

8. Когда переопределение может вызвать проблемы

// Проблема: параллельное использование equals()
@Entity
public class Entity {
    @Id
    private Long id;
    
    // НЕ переопределяем equals() — правильно
}

public void problem() {
    Entity entity = entityRepository.findById(1L);
    
    // ORM часто использует identity сравнение
    session.contains(entity);  // Проверяет: entity в session?
    // Если переопределить equals(), может вернуть неправильный результат
}

Резюме

Переопределяй equals() когда:

• Value Object (Money, Date, Email)
• DTO
• Domain Model Object
• Объект используется в коллекциях
• Business logic требует сравнения по значению

НЕ переопределяй equals() когда:

• Entity (Database entity)
• Объект уникален по identity
• Объект никогда не сравнивается
• ORM/Framework управляет объектом

Золотое правило: Если сомневаешься, лучше переопределить equals() и hashCode() чем не делать этого. Это более безопасно и явно выражает намерение.