Что значит вернувшийся из Comparator 0?

Что означает 0 из Comparator

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

Значение возвращаемого значения

Возвращаемое значение compare(a, b) имеет три возможных случая:

0 означает, что два объекта считаются равными по критерию сравнения.

Примеры

Пример 1: Сравнение чисел

Comparator<Integer> intComparator = (a, b) -> {
    if (a < b) return -1;
    if (a > b) return 1;
    return 0;  // a == b
};

int result1 = intComparator.compare(5, 10);  // -1 (5 < 10)
int result2 = intComparator.compare(10, 10); // 0 (10 == 10)
int result3 = intComparator.compare(15, 10); // 1 (15 > 10)

Пример 2: Сравнение строк

Comparator<String> stringComparator = (a, b) -> a.compareTo(b);

int result = stringComparator.compare("hello", "hello"); // 0 - строки равны

Пример 3: Сравнение объектов

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Comparator<Person> ageComparator = (p1, p2) -> {
    if (p1.getAge() < p2.getAge()) return -1;
    if (p1.getAge() > p2.getAge()) return 1;
    return 0; // Оба имеют одинаковый возраст
};

Person person1 = new Person("Alice", 30);
Person person2 = new Person("Bob", 30);

int result = ageComparator.compare(person1, person2); // 0 - одинаковый возраст

Применение в сортировке

Значение 0 используется алгоритмом сортировки для определения стабильности сортировки.

List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 25),
    new Person("Charlie", 30)
);

// Сортировка по возрасту
people.sort((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));

// Результат (стабильная сортировка):
// Alice (25), Bob (25), Charlie (30)
// Alice и Bob остаются в исходном порядке, т.к. comparator вернул 0

Важность 0 при поиске

Binary Search

Comparator<Integer> comparator = Integer::compare;
List<Integer> numbers = Arrays.asList(1, 3, 5, 7, 9);

int index = Collections.binarySearch(numbers, 5, comparator);
// index = 2 (элемент найден)
// Поиск зависит от Comparator, возвращающего 0

int notFound = Collections.binarySearch(numbers, 4, comparator);
// Не найдено, вернёт отрицательный индекс

TreeSet и TreeMap

Comparator<Integer> comparator = Integer::compare;

TreeSet<Integer> set = new TreeSet<>(comparator);
set.add(5);
set.add(5);  // Не будет добавлено! (comparator вернёт 0)
set.add(10);

System.out.println(set.size()); // 2, не 3

Это очень важно: если Comparator возвращает 0, элемент считается дублем и не добавляется в TreeSet.

Кастомный Comparator с 0

Сравнение по нескольким полям

public class Student {
    private String name;
    private int grade;
    private double gpa;
}

// Сортируем по grade, затем по GPA
Comparator<Student> comparator = (s1, s2) -> {
    int gradeComparison = Integer.compare(s1.getGrade(), s2.getGrade());
    
    if (gradeComparison != 0) {
        return gradeComparison; // Разные grade
    }
    
    // gradeComparison == 0, проверяем GPA
    return Double.compare(s1.getGpa(), s2.getGpa());
};

List<Student> students = new ArrayList<>();
students.add(new Student("Alice", 10, 4.0));
students.add(new Student("Bob", 10, 4.0));    // 0 при сравнении
students.add(new Student("Charlie", 11, 3.9));

students.sort(comparator);

Сравнение с null значениями

Comparator<String> nullSafeComparator = (a, b) -> {
    if (a == null && b == null) return 0;  // Оба null
    if (a == null) return -1;               // null считаем меньше
    if (b == null) return 1;                // a больше null
    return a.compareTo(b);
};

Практическое применение

Проверка равенства

Comparator<Integer> comparator = Integer::compare;

if (comparator.compare(10, 10) == 0) {
    System.out.println("Числа равны");
}

Определение дублей

List<String> names = Arrays.asList("Alice", "Bob", "Alice");
Comparator<String> comparator = String::compareTo;

Map<String, Integer> counts = new HashMap<>();
for (String name : names) {
    counts.merge(name, 1, Integer::sum);
}

// Или с использованием comparator
Set<String> uniqueNames = new TreeSet<>(comparator);
uniqueNames.addAll(names);
// ["Alice", "Bob"] — дубли исключены благодаря 0 из comparator

Техничные детали

Согласованность: Comparator должен быть транзитивным:

// Если compare(a, b) == 0 и compare(b, c) == 0
// То compare(a, c) должен быть == 0

Comparator<Integer> comparator = (a, b) -> {
    // Плохой comparator!
    if (Math.abs(a - b) <= 1) return 0;  // Близкие числа — равны
    return Integer.compare(a, b);
};

int r1 = comparator.compare(1, 2);  // 0
int r2 = comparator.compare(2, 3);  // 0
int r3 = comparator.compare(1, 3);  // -1 (!) нарушение транзитивности

Выводы

✓ 0 из Comparator означает равенство по критерию сравнения
✓ Важна для сортировки — элементы с нулевым сравнением остаются в исходном порядке
✓ Критична для Set и Map — элементы с 0 считаются дублями
✓ Используется в binary search — поиск основан на 0 из comparator
✓ Должен быть транзитивным — иначе поведение unpredictable

Понимание 0 в Comparator — это базовое, но критичное знание для работы с сортировкой и поиском в Java.