Как правильно сравнивать объекты

Правильное сравнение объектов в Java

Два типа сравнения

В Java есть два разных способа проверить, являются ли два объекта "одинаковыми":

1. == оператор — сравнивает ссылки (адреса в памяти)
2. .equals() метод — сравнивает содержимое объектов

Основные различия

String s1 = new String("Hello");
String s2 = new String("Hello");
String s3 = s1;

// Оператор ==
System.out.println(s1 == s2);  // false (разные объекты в памяти)
System.out.println(s1 == s3);  // true (одна и та же ссылка)

// Метод .equals()
System.out.println(s1.equals(s2));  // true (одинаковое содержимое)
System.out.println(s1.equals(s3));  // true (одинаковое содержимое)

Визуально:

s1 ──→ [Heap: "Hello"]  (объект 1)
s2 ──→ [Heap: "Hello"]  (объект 2)
s3 ──→ [Heap: "Hello"]  (объект 1, копия ссылки)

s1 == s2: false (разные адреса)
s1 == s3: true (один адрес)
s1.equals(s2): true (одно содержимое)
s1.equals(s3): true (одно содержимое)

Сравнение примитивов vs объектов

// Примитивы: == сравнивает значения
int a = 10;
int b = 10;
System.out.println(a == b);  // true (одинаковые значения)

// Объекты: == сравнивает ссылки
Integer x = new Integer(10);
Integer y = new Integer(10);
System.out.println(x == y);   // false (разные объекты)
System.out.println(x.equals(y)); // true (одинаковое содержимое)

// ИСКЛЮЧЕНИЕ: Integer кеширует значения -128..127
Integer m = 10;  // Integer.valueOf(10) — из кеша
Integer n = 10;  // Integer.valueOf(10) — из кеша
System.out.println(m == n);  // true (один объект из кеша)

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

Базовая реализация

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object obj) {
        // 1. Сравнить ссылки
        if (this == obj) {
            return true;  // Оптимизация для одного объекта
        }
        
        // 2. Проверить тип
        if (obj == null) {
            return false;  // null != объект
        }
        
        if (!(obj instanceof Person)) {
            return false;  // Разные типы
        }
        
        // 3. Кастировать и сравнить поля
        Person other = (Person) obj;
        return this.name.equals(other.name) && this.age == other.age;
    }
}

// Использование
Person p1 = new Person("John", 30);
Person p2 = new Person("John", 30);
Person p3 = new Person("Jane", 25);

System.out.println(p1.equals(p2)); // true (одинаковые данные)
System.out.println(p1.equals(p3)); // false (разные данные)
System.out.println(p1.equals(null)); // false
System.out.println(p1.equals("John")); // false (разные типы)

Перегрузка equals() для разных типов полей

import java.util.Objects;

public class User {
    private String email;
    private String username;
    private int age;
    private List<String> hobbies;  // Коллекция
    private Address address;       // Объект
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || !(obj instanceof User)) return false;
        
        User other = (User) obj;
        
        // Сравнение разных типов полей
        return Objects.equals(this.email, other.email)      // String
            && Objects.equals(this.username, other.username) // String
            && this.age == other.age                          // int
            && Objects.equals(this.hobbies, other.hobbies)   // List
            && Objects.equals(this.address, other.address);  // Object
    }
}

Обязательно: equals() и hashCode() вместе

Если переопределяешь equals(), ОБЯЗАТЕЛЬНО переопредели hashCode():

public class Product {
    private String code;
    private String name;
    private double price;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || !(obj instanceof Product)) return false;
        
        Product other = (Product) obj;
        return Objects.equals(this.code, other.code);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(code); // Основано на ТЕХ ЖЕ полях, что equals()
    }
}

// Почему важно
Set<Product> set = new HashSet<>();
Product p1 = new Product("SKU-001", "Laptop", 1000);
Product p2 = new Product("SKU-001", "Laptop", 1000);

set.add(p1);
set.add(p2);

// Если hashCode() правильный
System.out.println(set.size()); // 1 (оба имеют одинаковый хеш и equals)

// Если hashCode() неправильный
// Система подумает, что это разные объекты
System.out.println(set.size()); // 2 (НЕПРАВИЛЬНО!)

Используй Objects.equals() для null-safe сравнения

// ❌ Может выбросить NullPointerException
if (name.equals(other.name)) { }

// ✅ Безопасно для null
if (Objects.equals(name, other.name)) { }

// Objects.equals(a, b) эквивалентно:
// (a == null) ? (b == null) : a.equals(b)

Сравнение в коллекциях

List<String> list1 = Arrays.asList("apple", "banana");
List<String> list2 = Arrays.asList("apple", "banana");

System.out.println(list1 == list2);   // false (разные объекты)
System.out.println(list1.equals(list2)); // true (одинаковое содержимое)

// Set использует equals() и hashCode()
Set<String> set = new HashSet<>();
set.add("apple");
set.add("apple"); // Второй "apple" не добавляется
System.out.println(set.size()); // 1

// Map использует equals() для ключей
Map<String, Integer> map = new HashMap<>();
map.put("john", 25);
map.put(new String("john"), 30);
System.out.println(map.size()); // 1 (equals дал true)
System.out.println(map.get("john")); // 30 (последнее значение)

Правильный способ: используй IDE

IntelliJ IDEA и Eclipse генерируют equals() и hashCode():

// Right-click → Generate → equals() and hashCode()

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return age == person.age &&
           Objects.equals(name, person.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

Способ 2: Java 14+ Records (автоматически)

public record Person(String name, int age) {
    // equals(), hashCode(), toString() генерируются автоматически
}

// Использование
Person p1 = new Person("John", 30);
Person p2 = new Person("John", 30);
System.out.println(p1.equals(p2)); // true (автоматически правильно)

Способ 3: Project Lombok

@Data  // @EqualsAndHashCode + @ToString + getters/setters
public class Person {
    private String name;
    private int age;
}

// Все методы генерируются автоматически

Сравнение для разных типов

// String
String s1 = "hello";
String s2 = "hello";
System.out.println(s1.equals(s2)); // true (переопределён equals)

// Integer/Long
Integer i1 = 100;
Integer i2 = 100;
System.out.println(i1.equals(i2)); // true

// Date
Date d1 = new Date(1000000);
Date d2 = new Date(1000000);
System.out.println(d1.equals(d2)); // true

// LocalDate (Java 8)
LocalDate ld1 = LocalDate.of(2024, 1, 1);
LocalDate ld2 = LocalDate.of(2024, 1, 1);
System.out.println(ld1.equals(ld2)); // true

// Массивы
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println(arr1 == arr2); // false (разные объекты)
System.out.println(Arrays.equals(arr1, arr2)); // true (одинаковое содержимое)

Чеклист сравнения

• Используй equals() для сравнения объектов, не ==
• Реализуй equals() если создаёшь свой класс
• Реализуй hashCode() если реализуешь equals()
• Используй Objects.equals() для null-safe сравнения
• Тестируй equals() на null, разные типы, одинаковые данные
• Используй IDE для генерации
• Используй Records для автоматического equals()

Итог

Золотое правило: ВСЕГДА используй equals() для сравнения объектов, не == (кроме сравнения с null)!