Когда метод compareTo возвращает -1, а когда 1?

Метод compareTo: возвращаемые значения

Основная семантика

Метод compareTo() интерфейса Comparable<T> сравнивает текущий объект с переданным и возвращает целое число:

public interface Comparable<T> {
    int compareTo(T o);
}

Возвращаемые значения

Метод возвращает -1 (отрицательное число)

Когда текущий объект МЕНЬШЕ переданного:

String a = "apple";
String b = "banana";

int result = a.compareTo(b);  // -1 (a < b по алфавиту)

Логика: если я (текущий объект) меньше, чем ты (переданный объект), я возвращаю отрицательное число.

Метод возвращает 0

Когда объекты РАВНЫ:

String a = "apple";
String b = "apple";

int result = a.compareTo(b);  // 0

Метод возвращает 1 (положительное число)

Когда текущий объект БОЛЬШЕ переданного:

String a = "zebra";
String b = "apple";

int result = a.compareTo(b);  // 1 (a > b по алфавиту)

Логика: если я больше, чем ты, я возвращаю положительное число.

Запоминающаяся аналогия

Если this < other → return -1
Если this == other → return 0
Если this > other → return 1

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

Числа

Integer x = 5;
Integer y = 10;

x.compareTo(y);  // -1 (5 < 10)
y.compareTo(x);  // 1 (10 > 5)
x.compareTo(5);  // 0 (5 == 5)

Пользовательский класс

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

// Использование
Person alice = new Person("Alice", 25);
Person bob = new Person("Bob", 30);
Person charlie = new Person("Charlie", 25);

alice.compareTo(bob);      // -1 (25 < 30)
bob.compareTo(alice);       // 1 (30 > 25)
alice.compareTo(charlie);   // 0 (25 == 25)

Сортировка с помощью compareTo

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

Collections.sort(people);  // Сортирует по возрасту

// Результат:
// Bob (25)
// Alice (30)
// Charlie (35)

Более удобный способ с Integer.compare()

Вместо многострочной логики можно использовать утилиты:

public class Person implements Comparable<Person> {
    private int age;
    
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }
}

Работа с Comparator

Для более сложных сравнений используется Comparator:

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

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

// Обратная сортировка (descending)
Collections.sort(people, Comparator
    .comparingInt(Person::getAge)
    .reversed());

Договор Comparable

Если реализуешь compareTo(), должен соблюдать контракт:

// 1. Консистентность с equals
if (a.equals(b)) {
    assert a.compareTo(b) == 0;
}

// 2. Транзитивность
if (a.compareTo(b) < 0 && b.compareTo(c) < 0) {
    assert a.compareTo(c) < 0;  // true
}

// 3. Антисимметричность
if (a.compareTo(b) > 0) {
    assert b.compareTo(a) < 0;  // true
}

Частая ошибка

// ❌ НЕПРАВИЛЬНО — может быть переполнение
public int compareTo(Person other) {
    return this.age - other.age;  // Опасно при больших числах!
}

// ✓ ПРАВИЛЬНО
public int compareTo(Person other) {
    return Integer.compare(this.age, other.age);
}

Вывод

compareTo() возвращает:

• -1 (или любое отрицательное) — текущий объект МЕНЬШЕ
• 0 — объекты РАВНЫ
• 1 (или любое положительное) — текущий объект БОЛЬШЕ

Это стандартная семантика сравнения в Java, используется везде от Collections.sort() до TreeMap.