Для чего нужен Comparator?

# Для чего нужен Comparator?

Comparator — это интерфейс в Java, который определяет кастомный порядок сортировки объектов. Он позволяет сравнивать два объекта и определять, какой из них "больше", "меньше" или "равен".

Основная цель

Обеспечить гибкую сортировку объектов без изменения класса.

Когда нужен Comparator

1. Сортировка объектов, которые не реализуют Comparable

public class Person {
    String name;
    int age;
    // НЕ реализует Comparable!
}

// Но мы можем сортировать по имени
List<Person> people = new ArrayList<>();
people.sort(new Comparator<Person>() {
    public int compare(Person a, Person b) {
        return a.name.compareTo(b.name);
    }
});

2. Несколько способов сортировки одного класса

public class Student implements Comparable<Student> {
    String name;
    double gpa;
    
    // Comparablе по умолчанию сортирует по имени
    public int compareTo(Student other) {
        return this.name.compareTo(other.name);
    }
}

// Но нам нужны разные порядки:
students.sort(Comparator.comparing(s -> s.gpa)); // По GPA
students.sort(Comparator.comparing(s -> s.name)); // По имени

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

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);

// Сортировка от большего к меньшему
numbers.sort(Comparator.reverseOrder());
// Результат: [9, 5, 4, 3, 1, 1]

Разница между Comparable и Comparator

Примеры Comparator

1. Сортировка объектов по полям

public class Employee {
    String name;
    int salary;
    int years;
}

List<Employee> employees = new ArrayList<>();

// По зарплате (от низкой к высокой)
employees.sort((e1, e2) -> Integer.compare(e1.salary, e2.salary));

// По зарплате (от высокой к низкой)
employees.sort((e1, e2) -> Integer.compare(e2.salary, e1.salary));

// По имени
employees.sort((e1, e2) -> e1.name.compareTo(e2.name));

// Сначала по зарплате, потом по имени
employees.sort(
    Comparator.comparing((Employee e) -> e.salary)
              .thenComparing(e -> e.name)
);

2. Сортировка строк

List<String> words = Arrays.asList("java", "python", "c");

// По длине
words.sort(Comparator.comparing(String::length));
// Результат: [c, java, python]

// В обратном порядке по длине
words.sort(Comparator.comparing(String::length).reversed());
// Результат: [python, java, c]

3. Сортировка в TreeSet и TreeMap

// TreeSet обычно сортирует по Comparable
Set<Integer> set1 = new TreeSet<>(); // По возрастанию

// Но можем задать свой Comparator
Set<Integer> set2 = new TreeSet<>(Comparator.reverseOrder());
set2.addAll(Arrays.asList(5, 2, 8, 1));
// Результат: [8, 5, 2, 1] (по убыванию)

// TreeMap с кастомным Comparator
Map<String, Integer> map = 
    new TreeMap<>(Comparator.reverseOrder());
map.put("a", 1);
map.put("c", 3);
map.put("b", 2);
// Итерирует в порядке: "c", "b", "a" (обратный алфавит)

4. Сложная сортировка

public class Product {
    String name;
    double price;
    int rating;
}

List<Product> products = new ArrayList<>();

// Сортировка: сначала по рейтингу (высокий),
// потом по цене (низкая), потом по имени
products.sort(
    Comparator.comparing((Product p) -> p.rating).reversed()
              .thenComparing(p -> p.price)
              .thenComparing(p -> p.name)
);

5. Null-safe Comparator

List<String> strings = Arrays.asList("a", null, "b", "c", null);

// Без nullsFirst: NullPointerException
// strings.sort(Comparator.naturalOrder());

// С nullsFirst: null значения идут в начало
strings.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
// Результат: [null, null, a, b, c]

// С nullsLast: null значения идут в конец
strings.sort(Comparator.nullsLast(Comparator.naturalOrder()));
// Результат: [a, b, c, null, null]

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

public class MovieSortingExample {
    
    static class Movie {
        String title;
        int year;
        double rating;
        
        public Movie(String title, int year, double rating) {
            this.title = title;
            this.year = year;
            this.rating = rating;
        }
    }
    
    public static void main(String[] args) {
        List<Movie> movies = Arrays.asList(
            new Movie("Inception", 2010, 8.8),
            new Movie("Avatar", 2009, 7.8),
            new Movie("Titanic", 1997, 7.9)
        );
        
        // По году выпуска (новые первыми)
        movies.sort(
            Comparator.comparing((Movie m) -> m.year).reversed()
        );
        // Результат: Inception (2010), Avatar (2009), Titanic (1997)
        
        // По рейтингу (лучшие первыми)
        movies.sort(
            Comparator.comparing((Movie m) -> m.rating).reversed()
        );
        // Результат: Inception (8.8), Titanic (7.9), Avatar (7.8)
        
        // По названию (алфавитный порядок)
        movies.sort(Comparator.comparing(m -> m.title));
        // Результат: Avatar, Inception, Titanic
    }
}

Ключевые преимущества

✓ Гибкость — множество способов сортировки одного класса

✓ Не изменяет класс — можешь сортировать классы, которые ты не писал

✓ Легко комбинировать — thenComparing() для многоуровневой сортировки

✓ Поддержка null — nullsFirst(), nullsLast()

✓ Stream API — используется с sorted(), collect()

Вывод

Comparator — это критически важный инструмент для гибкой сортировки объектов. Он позволяет определить множество порядков сортировки для одного класса и используется во всех контейнерах Java (List, Set, Map).