Контракти Equals та HashCode

Equals та HashCode контракт: Глибокий аналіз

1. Детальний аналіз методу Equals()

1.1 Рефлексивність (x.equals(x) = true)

Теоретичне пояснення.
Рефлексивність означає, що для будь-якої ненульової змінної об'єкт повинен бути рівним сам собі. Це базується на аксіомах математичної рівності.

Приклад

public class Book {  
 private String name;  
 private String isbn;  
 @Override  
 public boolean equals(Object obj) {  
 // Невірна реалізація  
 if (obj == null) return false;  
 if (!(obj instanceof Book)) return false;  
 Book other = (Book) obj;  
 return isbn.equals(other.isbn); // Можливий NullPointerException!  
 // Вірна реалізація  
 if (this == obj) return true; // Забезпечує рефлексивність  
 if (obj == null || getClass() != obj.getClass()) return false;  
 Book other = (Book) obj;  
 return Objects.equals(isbn, other.isbn); // Безпечне порівняння  
 }  
}

1.2 Симетричність (x.equals(y) = y.equals(x))

Теоретичне пояснення
Симетричність означає, що якщо перший об'єкт рівний другому, то другий також повинен бути рівним першому. Ця властивість ускладнюється при використанні успадкування та композиції.

Приклад

public class Student {  
 private String id;  

 @Override  
 public boolean equals(Object obj) {  
 if (this == obj) return true;  
 if (obj == null) return false;  
 if (!(obj instanceof Student)) return false; // замість getClass() != obj.getClass()  
 return Objects.equals(id, ((Student) obj).id);  
 }  
}  
public class GraduateStudent extends Student {  
 private String thesis;  

 // Тут може порушитись симетричність!  
 @Override  
 public boolean equals(Object obj) {  
 if (!super.equals(obj)) return false;  
 if (!(obj instanceof GraduateStudent)) return false;  
 return Objects.equals(thesis, ((GraduateStudent) obj).thesis);  
 }  
}

1.3 Транзитивність (x.equals(y) && y.equals(z) => x.equals(z))

Теоретичне пояснення
Транзитивність визначає відношення між трьома об'єктами. Ця властивість часто порушується в ієрархії успадкування.

Приклад

public class Point {  
 private final int x;  
 private final int y;  

 @Override  
 public boolean equals(Object obj) {  
 if (this == obj) return true;  
 if (obj == null || getClass() != obj.getClass()) return false;  
 Point point = (Point) obj;  
 return x == point.x && y == point.y;  
 }  
}  
public class ColorPoint extends Point {  
 private final Color color;  

 // Реалізація, яка порушує транзитивність  
 @Override  
 public boolean equals(Object obj) {  
 if (!(obj instanceof Point)) return false;  
 if (!(obj instanceof ColorPoint)) {  
 return super.equals(obj); // Тут порушується симетричність!  
 }  
 return super.equals(obj) && Objects.equals(color, ((ColorPoint) obj).color);  
 }  

 // Вірне рішення: використовувати композицію  
 public class ColorPoint {  
 private final Point point;  
 private final Color color;  

 @Override  
 public boolean equals(Object obj) {  
 if (this == obj) return true;  
 if (obj == null || getClass() != obj.getClass()) return false;  
 ColorPoint that = (ColorPoint) obj;  
 return Objects.equals(point, that.point) &&   
 Objects.equals(color, that.color);  
 }  
 }  
}

1.4 Консистентність (однаковий результат при повторних викликах)

Теоретичне пояснення
Консистентність означає, що метод equals() повинен повертати однаковий результат, поки внутрішній стан об'єкта не зміниться.
Це особливо важливо в ситуаціях, коли об'єкти залежать від зовнішніх ресурсів.

Погані та хороші приклади

public class URLChecker {  
 private String url;  

 // Поганий приклад - порушує консистентність  
 @Override  
 public boolean equals(Object obj) {  
 if (obj == null || getClass() != obj.getClass()) return false;  
 URLChecker other = (URLChecker) obj;  
 try {  
 return new URL(url).getContent().equals(  
 new URL(other.url).getContent()  
 );  
 } catch (IOException e) {  
 return false;  
 }  
 }  

 // Хороший приклад  
 @Override  
 public boolean equals(Object obj) {  
 if (this == obj) return true;  
 if (obj == null || getClass() != obj.getClass()) return false;  
 URLChecker other = (URLChecker) obj;  
 return Objects.equals(url, other.url);  
 }  
}

1.5 Взаємодія з null (x.equals(null) = false)

Теоретичне пояснення
Порівняння з null завжди повинно повертати false. Це важливо для запобігання NullPointerException.

Правильні методи реалізації

public class NullExample {  
 private String data;  

 // Поганий спосіб - ризик NullPointerException  
 @Override  
 public boolean equals(Object obj) {  
 NullExample other = (NullExample) obj; // Ризик ClassCastException  
 return data.equals(other.data); // Ризик NullPointerException  
 }  

 // Хороший спосіб  
 @Override  
 public boolean equals(Object obj) {  
 if (this == obj) return true;  
 if (obj == null || getClass() != obj.getClass()) return false;  
 NullExample other = (NullExample) obj;  
 return Objects.equals(data, other.data); // Безпечна перевірка на null  
 }  
}

1. Глибокий аналіз методу HashCode()

2.1 Консистентність

Теоретичне пояснення
Консистентність методу hashCode важливіша, ніж консистентність equals(), оскільки вона впливає на роботу колекцій на основі хешів.

Приклад

public class ConsistentHash {  
 private final String data;  
 private int hashCode; // Закешований хеш-код  

 public ConsistentHash(String data) {  
 this.data = data;  
 }  

 @Override  
 public int hashCode() {  
 // Патерн ледачої ініціалізації  
 int h = hashCode;  
 if (h == 0 && data != null) {  
 h = data.hashCode();  
 hashCode = h;  
 }  
 return h;  
 }  
}

2.2 Зв'язок між equals та hashCode

Теоретичне пояснення
Коли equals() повертає true, hashCode() обов'язково має бути однаковим, але якщо hashCode() однаковий, то equals() не обов'язково має повернути true.

Приклад

public class Student {  
 private String name;  
 private String faculty;  
 private int year;  

 @Override  
 public boolean equals(Object obj) {  
 if (this == obj) return true;  
 if (obj == null || getClass() != obj.getClass()) return false;  
 Student other = (Student) obj;  
 return year == other.year &&   
 Objects.equals(name, other.name) &&   
 Objects.equals(faculty, other.faculty);  
 }  

 @Override  
 public int hashCode() {  
 // Поганий спосіб - не відповідає equals()  
 return Objects.hash(name, year); // faculty не враховано!  

 // Хороший спосіб  
 return Objects.hash(name, faculty, year);  
 }  
}

2.3 Мінімізація колізій

Теоретичне пояснення
Колізії — це коли різні об'єкти повертають однаковий хеш-код. Повністю уникнути цього неможливо, але слід мінімізувати їх кількість.

Оптимізований приклад методу hashCode

public class OptimizedHash {  
 private String text;  
 private int number;  

 @Override  
 public int hashCode() {  
 // Простий спосіб  
 return Objects.hash(text, number);  

 // Оптимізований спосіб  
 int result = 17; // Початкове значення з простого числа  
 result = 31 * result + (text != null ? text.hashCode() : 0);  
 result = 31 * result + number;  
 return result;  
 }  
}

Практичні поради та найкращі практики

3.1 Для незмінних (immutable) об'єктів

public final class ImmutableExample {
private final String data;
private final int hash; // Фіксований хеш-код

public ImmutableExample(String data) {
this.data = data;
this.hash = Objects.hash(data); // Обчислюється в конструкторі
}

@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
ImmutableExample other = (ImmutableExample) obj;
return Objects.equals(data, other.data);
}

@Override
public int hashCode() {
return hash; // Незмінне значення
}
}
```

3.2 Для складних об'єктів

public class ComplexObject {  
 private List items;  
 private Map metadata;  
 private Set identifiers;  

 @Override  
 public boolean equals(Object obj) {  
 if (this == obj) return true;  
 if (obj == null || getClass() != obj.getClass()) return false;  
 ComplexObject other = (ComplexObject) obj;  

 return Objects.equals(items, other.items) &&  
 Objects.equals(metadata, other.metadata) &&  
 Objects.equals(identifiers, other.identifiers);  
 }  

 @Override  
 public int hashCode() {  
 return Objects.hash(items, metadata, identifiers);  
 }  
}

1. Написання тестових випадків

@Test  
public void testEqualsContract() {  
 Student s1 = new Student("Ali", "12345");  
 Student s2 = new Student("Ali", "12345");  
 Student s3 = new Student("Ali", "12345");  

 // Рефлексивність  
 assertTrue(s1.equals(s1));  

 // Симетричність  
 assertTrue(s1.equals(s2) == s2.equals(s1));  

 // Транзитивність  
 if (s1.equals(s2) && s2.equals(s3)) {  
 assertTrue(s1.equals(s3));  
 }  

 // Тест на null  
 assertFalse(s1.equals(null));  

 // Консистентність hashCode  
 if (s1.equals(s2)) {  
 assertEquals(s1.hashCode(), s2.hashCode());  
 }  
}

1. Висновок
   Правильна реалізація контрактів equals та hashCode є складним завданням, але важливо дотримуватись наступних правил:

2. Завжди перевизначайте обидва методи разом

3. Дотримуйтесь усіх контрактних правил

4. Вибирайте композицію, а не наслідування

5. Для незмінних об'єктів кешуйте хеш-код

6. Не забувайте писати тестові випадки

Порушення цих контрактів може призвести до непередбачуваних помилок у вашій програмі, особливо при роботі з такими колекціями, як HashMap, HashSet.

Перекладено з: Equals va HashCode kontraktlari