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

// Рекомендуется (но не обязательно), чтобы:
x.compareTo(y) == 0 ⇔ x.equals(y) == true
Нарушение этого принципа может привести к тонким ошибкам, особенно при использовании в коллекциях, основанных на упорядочивании (например, TreeSet, TreeMap).

BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("1.00");

System.out.println(bd1.equals(bd2));    // false (разный масштаб)
System.out.println(bd1.compareTo(bd2)); // 0 (равны по значению)
Это историческое решение было принято для соответствия стандарту ANSI SQL, но оно служит предостережением о сложностях реализации сравнения.

public int compareTo(Employee other) {
    int result = this.lastName.compareTo(other.lastName);
    if (result != 0) return result;
    
    result = this.firstName.compareTo(other.firstName);
    if (result != 0) return result;
    
    return this.hireDate.compareTo(other.hireDate);
}
Такой подход создает иерархический порядок, где более значимые поля сравниваются первыми.

public int compareTo(Person other) {
    if (other == null) {
        throw new NullPointerException("Cannot compare with null");
    }
    // ... сравнение
}
Это решение основано на принципе "явное лучше неявного" — лучше получить немедленное исключение, чем молчаливую ошибку в логике упорядочивания.

// Упрощенная концепция реализации
public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    
    for (int k = 0; k < lim; k++) {
        char c1 = value[k];
        char c2 = anotherString.value[k];
        if (c1 != c2) {
            return c1 - c2; // Сравнение символов
        }
    }
    return len1 - len2; // Более короткая строка "меньше"
}

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
Обратите внимание на использование статического метода compare, который появился в Java 7 для улучшения читаемости.

LocalDate date1 = LocalDate.of(2023, 1, 1);
LocalDate date2 = LocalDate.of(2023, 12, 31);

int result = date1.compareTo(date2); // Отрицательное число

// ОПАСНО: возможное переполнение!
public int compareTo(MyInteger other) {
    return this.value - other.value;
}
При больших значениях разность может выйти за пределы int, что приведет к некорректным результатам.

public int compareTo(MyInteger other) {
    return Integer.compare(this.value, other.value);
}

// ОПАСНО: нарушение транзитивности из-за NaN!
public int compareTo(DoubleWrapper other) {
    return Double.compare(this.value, other.value);
    // Double.compare корректно обрабатывает NaN
}

Значения с плавающей точкой, особенно NaN, требуют особой осторожности при сравнении.

public int compareTo(Object other) {
    if (!(other instanceof MyClass)) {
        throw new ClassCastException("Cannot compare different types");
    }
    return compareTo((MyClass) other);
}

public class Employee implements Comparable<Employee> {
    private final String name;
    private final LocalDate hireDate;
    
    @Override
    public int compareTo(Employee other) {
        // Делегируем сравнение имени
        int nameComparison = this.name.compareTo(other.name);
        if (nameComparison != 0) {
            return nameComparison;
        }
        // При равных именах сравниваем даты найма
        return this.hireDate.compareTo(other.hireDate);
    }
}

Collections.sort(list, Collections.reverseOrder());
// Или для конкретного компаратора
Collections.sort(list, Comparator.reverseOrder());
Паттерн "Null-safe сравнение"
С Java 8 появились удобные методы для null-safe сравнения:

java
public int compareTo(Product other) {
    return Comparator.comparing(Product::getName, 
                                Comparator.nullsFirst(String::compareTo))
                     .thenComparing(Product::getPrice)
                     .compare(this, other);
}

public int compareTo(Person other) {
    // Вместо: return this.age - other.age;
    return Integer.compare(this.age, other.age);
}
Эти методы не только безопасны от переполнения, но и часто лучше оптимизируются JVM.

public final class ComplexNumber implements Comparable<ComplexNumber> {
    private final double real;
    private final double imaginary;
    private transient int hash; // Кэшированный хэш-код
    private transient Integer comparisonCache; // Кэш сравнения
    
    @Override
    public int compareTo(ComplexNumber other) {
        if (comparisonCache == null) {
            // Дорогое вычисление порядка
            comparisonCache = computeComparisonValue();
        }
        // Сравнение на основе кэшированного значения
        return comparisonCache.compareTo(other.getComparisonCache());
    }
}

import java.util.*;

public class Task201225 {
    public static void main(String[] args) {
        List<Number> list = new ArrayList<>();
        list.add(10);     // Integer
        list.add(5.5);    // Double
        list.add(3);      // Integer
        list.add(2.0);    // Double
        
        Collections.sort(list);
        
        System.out.println(list);
    }
}