Содержит ли Integer Comparator

Integer Comparator в Java

Ответ: ДА, Integer содержит методы для сравнения

Способы сравнения Integer

1. Integer.compare() (статический метод)

int result = Integer.compare(5, 10);
// result = -1 (5 < 10)

int result = Integer.compare(10, 10);
// result = 0 (10 == 10)

int result = Integer.compare(15, 10);
// result = 1 (15 > 10)

2. Integer.compareTo() (методи Instance)

Integer a = 5; Integer b = 10;

int result = a.compareTo(b);
// result = -1 (5 < 10)

3. Comparator interface

// Java 8+ более элегантно

Comparator<Integer> comp = Integer::compare;

// или

Comparator<Integer> comp = Comparator.naturalOrder();

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

Сортировка массива Integer

Integer[] numbers = {5, 2, 8, 1, 9}; Arrays.sort(numbers, Integer::compare);

// {1, 2, 5, 8, 9}

Сортировка List

List<Integer> list = Arrays.asList(5, 2, 8, 1, 9); list.sort(Integer::compare);

// или

Collections.sort(list); // по умолчанию использует compareTo

Обратный порядок

list.sort(Integer::compare); // ascending list.sort((a, b) -> Integer.compare(b, a)); // descending

// или

list.sort(Comparator.reverseOrder());

Stream операции

List<Integer> list = Arrays.asList(5, 2, 8, 1, 9);

// Min
int min = list.stream()
    .min(Integer::compare)
    .orElse(Integer.MIN_VALUE);
// 1

// Max
int max = list.stream()
    .max(Integer::compare)
    .orElse(Integer.MAX_VALUE);
// 9

// Sort

List<Integer> sorted = list.stream()

    .sorted(Integer::compare)
    .collect(Collectors.toList());
// [1, 2, 5, 8, 9]

Integer.compare vs compareTo

Integer.compare(a, b)

• Статический метод
• Безопасен для null? Нет, оба null выбросят NPE
• Параметры: два Integer

a.compareTo(b)

• Метод instance
• a не может быть null (NPE)
• b может быть null? Нет, все равно NPE

Custom Comparator с Integer

@Data

class User {
    String name;
    Integer age;
}

List<User> users = Arrays.asList(

    new User("Alice", 25),
    new User("Bob", 30),
    new User("Carol", 28)
);

// Сортировка по age

users.sort(Comparator.comparing(User::getAge));

// Alice (25), Carol (28), Bob (30)

// Сортировка по age с Integer::compare

users.sort((a, b) -> Integer.compare(a.getAge(), b.getAge()));

// Результат тот же

// Сортировка по age descending

users.sort((a, b) -> Integer.compare(b.getAge(), a.getAge()));

// Bob (30), Carol (28), Alice (25)

Comparator.comparing для Integer полей

// Проще использовать Comparator.comparing

users.sort(Comparator.comparing(User::getAge));

// Что эквивалентно:

users.sort(new Comparator<User>() {

    @Override
    public int compare(User a, User b) {
        return Integer.compare(a.getAge(), b.getAge());
    }

});

Performance

Integer.compare() vs a.compareTo(b):

• Performance практически одинаков
• Integer.compare() немного безопаснее (null checks)

Интересный факт

Долгое время Integer.compare() не было!

// Java 6-7
int a = 5, b = 10;
int result = a - b; // ОПАСНО!
// Может быть Integer overflow при отрицательных значениях
// Example: Integer.MIN_VALUE - 1 = Integer.MIN_VALUE - 1 overflow!

// Java 8+
int result = Integer.compare(a, b); // Безопасно

Главные выводы

1. Integer.compare() — статический метод, безопасный
2. Integer.compareTo() — метод instance
3. Comparator.comparing() — элегантнее для fields
4. Всегда используй Integer.compare() вместо a - b
5. Streams работают с этим хорошо (min, max, sorted)