Что такое интерфейс Comparable?

Интерфейс Comparable

Comparable — это встроенный интерфейс в Java (из пакета java.lang), который определяет естественный порядок сортировки для объектов класса. Класс, реализующий Comparable, может сравниваться с другими объектами того же типа и использоваться в методах сортировки.

Основной метод: compareTo()

public interface Comparable<T> {
    // Возвращает:
    // -1 или отрицательное число, если this < other
    //  0, если this == other
    //  1 или положительное число, если this > other
    int compareTo(T other);
}

Простой пример: сортировка чисел

public class Student implements Comparable<Student> {
    private String name;
    private double gpa;  // GPA — средний балл
    
    public Student(String name, double gpa) {
        this.name = name;
        this.gpa = gpa;
    }
    
    @Override
    public int compareTo(Student other) {
        // Сортируем студентов по GPA в порядке убывания
        if (this.gpa > other.gpa) {
            return -1;  // this идёт раньше
        } else if (this.gpa < other.gpa) {
            return 1;   // other идёт раньше
        } else {
            return 0;   // равны
        }
    }
    
    // Краткая версия с использованием Double.compare()
    // @Override
    // public int compareTo(Student other) {
    //     return Double.compare(other.gpa, this.gpa);  // убывание
    // }
    
    public String getName() { return name; }
    public double getGpa() { return gpa; }
    
    @Override
    public String toString() {
        return name + " (GPA: " + gpa + ")";
    }
}

public class ComparableDemo {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 3.5),
            new Student("Bob", 3.8),
            new Student("Charlie", 3.2)
        );
        
        System.out.println("До сортировки: " + students);
        
        Collections.sort(students);  // Использует compareTo()
        // или: students.sort(null);
        // или: students.sort(Comparator.naturalOrder());
        
        System.out.println("После сортировки: " + students);
    }
}

Вывод:

До сортировки: [Alice (GPA: 3.5), Bob (GPA: 3.8), Charlie (GPA: 3.2)]
После сортировки: [Bob (GPA: 3.8), Alice (GPA: 3.5), Charlie (GPA: 3.2)]

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

public class CompareToExamples {
    public static void main(String[] args) {
        String a = "apple";
        String b = "banana";
        String c = "apple";
        
        System.out.println(a.compareTo(b));  // < 0, так как apple < banana
        System.out.println(b.compareTo(a));  // > 0, так как banana > apple
        System.out.println(a.compareTo(c));  // 0, так как они равны
        
        // Для Integer
        Integer x = 5;
        Integer y = 10;
        Integer z = 5;
        
        System.out.println(x.compareTo(y));  // -1
        System.out.println(y.compareTo(x));  // 1
        System.out.println(x.compareTo(z));  // 0
    }
}

Практический пример: сортировка объектов

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) {
        // Способ 1: Явное сравнение
        // return Integer.compare(this.age, other.age);
        
        // Способ 2: Через вычитание (опасно при Integer.MIN_VALUE)
        // return this.age - other.age;  // ❌ Не рекомендуется
        
        // Способ 3: Через if-else (безопаснее)
        if (this.age < other.age) return -1;
        if (this.age > other.age) return 1;
        
        // Если возрасты равны, сортируем по имени
        return this.name.compareTo(other.name);
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
    
    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class Demo {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 30),
            new Person("David", 25)
        );
        
        Collections.sort(people);
        
        for (Person p : people) {
            System.out.println(p);
        }
    }
}

Вывод:

Bob (25)
David (25)
Alice (30)
Charlie (30)

Comparable vs Comparator

// ✅ Comparable — естественный порядок класса
public class Student implements Comparable<Student> {
    private String name;
    private double gpa;
    
    @Override
    public int compareTo(Student other) {
        return Double.compare(this.gpa, other.gpa);  // Естественный порядок
    }
}

// Использование
Collections.sort(students);  // Использует Comparable

// ❌ Comparator — альтернативный порядок (можно несколько)
public static final Comparator<Student> BY_NAME = 
    Comparator.comparing(Student::getName);

public static final Comparator<Student> BY_GPA_DESC = 
    Comparator.comparingDouble(Student::getGpa).reversed();

// Использование
students.sort(BY_NAME);      // Сортировка по имени
students.sort(BY_GPA_DESC);  // Сортировка по GPA в обратном порядке

Сортировка массивов и коллекций

public class SortingExamples {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
        System.out.println("До сортировки: " + numbers);
        
        Collections.sort(numbers);  // Использует Comparable<Integer>
        System.out.println("После сортировки: " + numbers);  // [1, 2, 5, 8, 9]
        
        // Сортировка массива
        String[] fruits = {"banana", "apple", "orange"};
        Arrays.sort(fruits);  // Использует Comparable<String>
        System.out.println(Arrays.toString(fruits));  // [apple, banana, orange]
        
        // Stream и сортировка
        List<Integer> filtered = numbers.stream()
            .filter(n -> n > 3)
            .sorted()  // Использует Comparable<Integer>
            .collect(Collectors.toList());
        System.out.println("Отфильтровано и отсортировано: " + filtered);
    }
}

Сортировка в обратном порядке

public class ReverseSort {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
        
        // Способ 1: Collections.reverseOrder()
        Collections.sort(numbers, Collections.reverseOrder());
        System.out.println(numbers);  // [9, 8, 5, 2, 1]
        
        // Способ 2: Comparator.reverseOrder()
        List<String> words = Arrays.asList("cat", "ant", "dog");
        words.sort(Comparator.reverseOrder());
        System.out.println(words);  // [dog, cat, ant]
        
        // Способ 3: Custom Comparator
        List<Student> students = Arrays.asList(
            new Student("Alice", 3.5),
            new Student("Bob", 3.8)
        );
        students.sort((s1, s2) -> Double.compare(s2.getGpa(), s1.getGpa()));
        System.out.println(students);
    }
}

TreeSet и Comparable

public class TreeSetExample {
    public static void main(String[] args) {
        // TreeSet использует compareTo() для сортировки
        Set<Integer> numbers = new TreeSet<>(Arrays.asList(5, 2, 8, 1, 9));
        System.out.println(numbers);  // [1, 2, 5, 8, 9] — автоматически отсортировано
        
        Set<String> words = new TreeSet<>(Arrays.asList("cat", "ant", "dog"));
        System.out.println(words);  // [ant, cat, dog]
    }
}

Контракт compareTo()

При реализации compareTo() нужно соблюдать важные правила:

public class ComparableContract implements Comparable<ComparableContract> {
    private int value;
    
    public ComparableContract(int value) {
        this.value = value;
    }
    
    @Override
    public int compareTo(ComparableContract other) {
        return Integer.compare(this.value, other.value);
    }
    
    // Контракт:
    // 1. sgn(compareTo(y)) == -sgn(y.compareTo(x))
    // 2. (x.compareTo(y) > 0 && y.compareTo(z) > 0) => x.compareTo(z) > 0
    // 3. (x.compareTo(y) == 0) => для всех z: sgn(x.compareTo(z)) == sgn(y.compareTo(z))
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ComparableContract)) return false;
        ComparableContract that = (ComparableContract) o;
        return value == that.value;  // Рекомендуется: (compareTo == 0) <=> equals()
    }
    
    @Override
    public int hashCode() {
        return Integer.hashCode(value);
    }
}

Лучшие практики

1. Используй встроенные методы — Integer.compare(), Double.compare()
2. Избегай простого вычитания — может привести к переполнению
3. Согласованность с equals() — если compareTo() == 0, то equals() должна вернуть true
4. Один естественный порядок — обычно выбирают самый логичный
5. Используй Comparator для альтернативных порядков сортировки
6. Stream API — поддерживает сортировку через sorted()

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