Какие знаешь виды сравнений?

Виды сравнений в Java

Сравнение — это фундаментальная операция в программировании. В Java существует несколько способов сравнения объектов, каждый имеет свой смысл и применение. Разберёмся в каждом из них.

1. Оператор == (сравнение ссылок)

Оператор == проверяет, ссылаются ли две переменные на ОДИН И ТОТ ЖЕ объект в памяти.

Сравнение примитивных типов

int a = 5;
int b = 5;

if (a == b) {  // true: значения одинаковые
    System.out.println("Equal values");
}

Сравнение ссылочных типов (объектов)

String str1 = new String("hello");
String str2 = new String("hello");
String str3 = str1;

str1 == str2  // false: разные объекты в памяти
str1 == str3  // true: одна и та же ссылка

Визуализация памяти:

Загромождение памяти:
     Heap
┌─────────────────┐
│ String "hello"  │  ← str1, str3 указывают сюда
└─────────────────┘
┌─────────────────┐
│ String "hello"  │  ← str2 указывает на другой объект
└─────────────────┘

str1 == str3  →  true  (одна ссылка)
str1 == str2  →  false (разные объекты)

Когда использовать:

• Сравнение примитивов
• Проверка, это один и тот же объект в памяти?
• Сравнение null: if (obj == null)

2. Метод equals() (сравнение содержимого)

Метод equals() сравнивает СОДЕРЖИМОЕ объектов, а не их идентичность.

equals() по умолчанию (Object)

public class Object {
    public boolean equals(Object obj) {
        return this == obj;  // По умолчанию сравнивает ссылки
    }
}

Все классы наследуют equals() из Object. Если не переопределить, он работает как ==.

equals() в String

String str1 = new String("hello");
String str2 = new String("hello");

str1 == str2          // false: разные объекты
str1.equals(str2)     // true: содержимое одинаковое

String переопределяет equals():

public class String {
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof String)) return false;
        
        String other = (String) obj;
        if (this.length() != other.length()) return false;
        
        // Сравнивает символы
        for (int i = 0; i < this.length(); i++) {
            if (this.charAt(i) != other.charAt(i)) {
                return false;
            }
        }
        return true;
    }
}

Правильно переопределять equals()

public class Person {
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;  // Одинаковая ссылка
        if (obj == null) return false;  // null не равен ничему
        if (!(obj instanceof Person)) return false;  // Разные типы
        
        Person other = (Person) obj;
        return this.name.equals(other.name) && 
               this.age == other.age;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

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

p1.equals(p2)  // true: одинаковое содержимое
p1.equals(p3)  // false: разное содержимое

Когда использовать:

• Сравнение содержимого объектов
• Проверка, равны ли два объекта по смыслу?
• Поиск элемента в коллекции

3. Метод compareTo() (сравнение с упорядочением)

Метод compareTo() вводит упорядочение между объектами. Возвращает:

• < 0 если this меньше other
• 0 если this равен other
• > 0 если this больше other

Реализация Comparable

public class Person implements Comparable<Person> {
    private String name;
    private int age;
    
    @Override
    public int compareTo(Person other) {
        // Сравниваем по возрасту
        if (this.age < other.age) return -1;
        if (this.age > other.age) return 1;
        return 0;  // Возраст одинаков
        
        // Или короче:
        // return Integer.compare(this.age, other.age);
    }
}

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

p1.compareTo(p2)  // > 0  (John старше Jane)
p1.compareTo(p3)  // 0    (одинаковый возраст)
p2.compareTo(p1)  // < 0  (Jane моложе John)

Сортировка с Comparable

List<Person> people = Arrays.asList(
    new Person("John", 30),
    new Person("Jane", 25),
    new Person("Bob", 35)
);

Collections.sort(people);  // Сортирует по compareTo()
// Результат: Jane(25), John(30), Bob(35)

4. Компаратор (Comparator) — внешнее сравнение

Eсли нужно сравнивать объекты разными способами, используй Comparator.

Реализация Comparator

Comparator<Person> byName = new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.name.compareTo(p2.name);
    }
};

Comparator<Person> byAge = new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.age, p2.age);
    }
};

List<Person> people = Arrays.asList(...);

people.sort(byName);  // Сортировка по имени
people.sort(byAge);   // Сортировка по возрасту

Lambda версия (Java 8+)

List<Person> people = Arrays.asList(...);

people.sort((p1, p2) -> p1.name.compareTo(p2.name));  // По имени
people.sort((p1, p2) -> Integer.compare(p1.age, p2.age));  // По возрасту

Использование Comparator.comparing()

List<Person> people = Arrays.asList(...);

people.sort(Comparator.comparing(Person::getName));      // По имени
people.sort(Comparator.comparing(Person::getAge));       // По возрасту
people.sort(Comparator.comparing(Person::getAge).reversed());  // По возрасту, обратно

Множественное сравнение (thenComparing)

// Сортируем сначала по возрасту, потом по имени
people.sort(
    Comparator.comparing(Person::getAge)
              .thenComparing(Person::getName)
);

5. equalsIgnoreCase() для строк

String str1 = "Hello";
String str2 = "hello";

str1.equals(str2)            // false
str1.equalsIgnoreCase(str2)  // true

6. contentEquals() для String и StringBuilder

String str = "hello";
StringBuilder sb = new StringBuilder("hello");

str.equals(sb)          // false
str.contentEquals(sb)   // true

Таблица сравнения видов сравнений

Важные правила

Правило 1: Если переопределяешь equals(), переопределяй hashCode()

// НЕПРАВИЛЬНО
public class Bad {
    private int value;
    
    @Override
    public boolean equals(Object obj) {
        return this.value == ((Bad) obj).value;
    }
    // hashCode() не переопределён!
}

// ПРАВИЛЬНО
public class Good {
    private int value;
    
    @Override
    public boolean equals(Object obj) {
        return this.value == ((Good) obj).value;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

Почему? Потому что HashMap, HashSet используют hashCode() для поиска:

Set<Bad> badSet = new HashSet<>();
Bad b1 = new Bad(5);
Bad b2 = new Bad(5);

badSet.add(b1);
if (badSet.contains(b2)) {  // false! (hashCode() разные)
    System.out.println("Found");
}

// С Good это работает правильно

Правило 2: Все три должны быть согласованы

Если a.equals(b) вернёт true, то:

• a.hashCode() == b.hashCode() должно быть true
• a.compareTo(b) == 0 должно быть true (если используешь Comparable)

Правило 3: equals() должен быть транзитивным

if (a.equals(b) && b.equals(c)) {
    // a должен быть равен c
    assert a.equals(c);  // true
}

Примеры в Collections

Поиск в List

List<String> list = Arrays.asList("apple", "banana", "cherry");

if (list.contains("banana")) {  // Использует equals()
    System.out.println("Found");
}

Поиск в Set

Set<String> set = new HashSet<>(Arrays.asList("apple", "banana"));

if (set.contains("apple")) {  // Использует hashCode() + equals()
    System.out.println("Found");
}

Поиск в Map

Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);

if (map.containsKey("apple")) {  // Использует hashCode() + equals()
    System.out.println("Found");
}

Практический пример

public class Employee implements Comparable<Employee> {
    private int id;
    private String name;
    private BigDecimal salary;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || !(obj instanceof Employee)) return false;
        
        Employee other = (Employee) obj;
        return this.id == other.id;  // Сравниваем по ID
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
    
    @Override
    public int compareTo(Employee other) {
        return Integer.compare(this.id, other.id);  // По ID
    }
    
    public static Comparator<Employee> byName() {
        return Comparator.comparing(Employee::getName);
    }
    
    public static Comparator<Employee> bySalary() {
        return Comparator.comparing(Employee::getSalary).reversed();
    }
}

// Использование
Set<Employee> employees = new HashSet<>();
employees.add(new Employee(1, "John", new BigDecimal("5000")));
employees.add(new Employee(2, "Jane", new BigDecimal("6000")));

// Сортировка
List<Employee> sorted = employees.stream()
    .sorted(Employee.byName())  // По имени
    .collect(Collectors.toList());

Выводы

1. Используй == для примитивов и проверки null
2. Переопределяй equals() чтобы сравнивать содержимое объектов
3. Всегда переопределяй hashCode() вместе с equals()
4. Используй Comparable когда есть естественный порядок сортировки
5. Используй Comparator для гибкого упорядочения
6. Тестируй сравнения особенно в HashSet, HashMap
7. Документируй semantics — что означает равность объектов в твоём классе