Comparator.thenComparing: примеры (JAVA)

Короткие примеры использования

Несколько простых сценариев с кодом и выводом.

1. Сортировка строк по длине, затем по алфавиту

import java.util.*;

List<String> words = new ArrayList<>(Arrays.asList("bee", "apple", "dog", "ant", "apply"));
words.sort(Comparator.comparing(String::length).thenComparing(String::compareTo));
System.out.println(words);

[ant, bee, dog, apple, apply]

2. Сортировка объектов Person по возрасту, затем по имени

import java.util.*;
class Person { String name; int age; Person(String n,int a){name=n;age=a;} public String toString(){return name+"("+age+")";} public String getName(){return name;} public int getAge(){return age;} }

List<Person> people = Arrays.asList(new Person("Ivan",30), new Person("Anna",25), new Person("Alex",30));
people.sort(Comparator.comparing(Person::getAge).thenComparing(Person::getName));
System.out.println(people);

[Anna(25), Alex(30), Ivan(30)]

3. Использование thenComparingInt для производительного сравнения

import java.util.*;
class Item { String id; int qty; Item(String i,int q){id=i;qty=q;} public String toString(){return id+":"+qty;} public int getQty(){return qty;} }

List<Item> items = Arrays.asList(new Item("A",10), new Item("B",5), new Item("C",10));
items.sort(Comparator.comparing(Item::getQty).thenComparingInt(i -> i.id.charAt(0)));
System.out.println(items);

[B:5, A:10, C:10]

4. С использованием nullsFirst и компаратора ключей

import java.util.*;
List<String> list = Arrays.asList("b", null, "a");
Comparator<String> cmp = Comparator.nullsFirst(Comparator.naturalOrder());
list.sort(cmp.thenComparing(String::length));
System.out.println(list);

[null, a, b]

Альтернативы в Java и их особенности

• Comparator.thenComparingInt/Long/Double - специализированы для примитивных ключей, предпочтительны при большом количестве сравнений для избежания автоупаковки.
• Comparator.comparing() - удобен для построения первичного компаратора из функции-ключа, часто используется в цепочке с thenComparing.
• Comparator.nullsFirst / nullsLast - управляют обработкой null-значений и обычно комбинируются с thenComparing для безопасного сравнения полей.
• Comparator.reversed() - инверсия порядка; применяется к первичному или вторичному компаратору при необходимости обратного порядка.
• Stream.sorted() и Collections.sort()/Arrays.sort() - разные контексты применения: первый применяется в потоках, вторые напрямую сортируют коллекции или массивы.

Предпочтения зависят от ситуации: для простых ключей и читаемости часто достаточно comparing плюс thenComparing. Для примитивов и производительности выгоднее использовать специализированные перегрузки. Для работы с null лучше явно применять nullsFirst/Last.

Аналоги в других языках и отличия

Краткие эквиваленты с примерами и выводом.

Python (sorted с ключом или tuple)

data = [(30, 'Ivan'), (25, 'Anna'), (30, 'Alex')]
# Сортировка по возрасту, затем по имени
print(sorted(data, key=lambda x: (x[0], x[1])))

[(25, 'Anna'), (30, 'Alex'), (30, 'Ivan')]

В Python ключи комбинируются в кортеж; поведение похоже, но нет явного thenComparing, и сравнение кортежей выполняется автоматически.

JavaScript (Array.sort с функцией сравнения)

let people = [{name:'Ivan',age:30},{name:'Anna',age:25},{name:'Alex',age:30}];
people.sort((a,b) => a.age - b.age || a.name.localeCompare(b.name));
console.log(people);

[{name:'Anna',age:25},{name:'Alex',age:30},{name:'Ivan',age:30}]

В JS часто используется короткая логика с оператором || для цепочки сравнений. Отличие: отсутствие типовой безопасности и перегрузок для примитивов.

C# (LINQ OrderBy then ThenBy)

using System;using System.Linq; var people = new[]{ new {Name="Ivan",Age=30}, new {Name="Anna",Age=25}, new {Name="Alex",Age=30} };
var sorted = people.OrderBy(p => p.Age).ThenBy(p => p.Name);
Console.WriteLine(string.Join(",", sorted.Select(p => p.Name)));

Anna,Alex,Ivan

В C# есть встроенные ThenBy/ThenByDescending, похожие по семантике на thenComparing.

PHP (usort с кастомной функцией)

$a = [['name'=>'Ivan','age'=>30],['name'=>'Anna','age'=>25],['name'=>'Alex','age'=>30)];
usort($a, function($x,$y){ $r=$x['age']-$y['age']; return $r?$r:strcmp($x['name'],$y['name']); });
print_r($a);

Array ( [0] => Array ( [name] => Anna [age] => 25 ) ... )

SQL (ORDER BY несколько столбцов)

SELECT name, age FROM people ORDER BY age ASC, name ASC;

-- строки в порядке по age, затем name

Go (sort.Slice с цепочкой проверок)

package main
import ("fmt";"sort")
type P struct{ Name string; Age int }
func main(){ people := []P{{"Ivan",30},{"Anna",25},{"Alex",30}}
sort.Slice(people, func(i,j int) bool { if people[i].Age!=people[j].Age { return people[i].Age<people[j].Age } return people[i].Name<people[j].Name })
fmt.Println(people)
}

[{Anna 25} {Alex 30} {Ivan 30}]

Kotlin (compareBy then compareByDescending)

data class Person(val name:String,val age:Int)
val people = listOf(Person("Ivan",30),Person("Anna",25),Person("Alex",30))
val sorted = people.sortedWith(compareBy(Person::age).thenBy(Person::name))
println(sorted)

[Person(name=Anna, age=25), Person(name=Alex, age=30), Person(name=Ivan, age=30)]

Lua (table.sort с функцией)

local t = {{name='Ivan',age=30},{name='Anna',age=25},{name='Alex',age=30}}
table.sort(t, function(a,b) if a.age~=b.age then return a.age<b.age end return a.name<b.name end)
for _,v in ipairs(t) do print(v.name) end

Anna
Alex
Ivan

В большинстве языков цепочка сравнения реализуется через пользовательскую функцию сравнения или компоновку ключей. Java предлагает типобезопасный API с перегрузками для примитивов и комбинацией с nullsFirst/Last, что упрощает и оптимизирует код по сравнению с универсальными функциями в динамических языках.

Типичные ошибки при использовании thenComparing

• Передача null в качестве Comparator или keyExtractor - приводит к NullPointerException.
• Использование перегрузки без компаратора для ключей, которые не реализуют Comparable - приводит к ClassCastException во время сравнения.
• Изменяемые поля в качестве ключей - может нарушить упорядоченность и привести к непредсказуемым результатам при использовании в структурах, зависящих от порядка (например, TreeSet).
• Несогласованность компаратора с equals - при использовании в упорядоченных коллекциях может возникнуть нарушение инвариантов.

Пример: NPE при null keyExtractor

Comparator<String> cmp = Comparator.naturalOrder();
cmp.thenComparing((java.util.function.Function<String,Integer>)null);

Exception in thread "main" java.lang.NullPointerException
    at java.util.Comparator.thenComparing(Comparator.java:...)
    ...

Пример: ClassCastException при отсутствии Comparable

class X {}
List<X> list = Arrays.asList(new X(), new X());
Comparator<X> cmp = Comparator.comparing(x -> x); // ключ X не Comparable
list.sort(cmp);

Exception in thread "main" java.lang.ClassCastException: X cannot be cast to java.lang.Comparable
    at java.util.Comparators"..."
    ...

Ошибки обычно выявляются при раннем тестировании; для безопасной работы рекомендуется явно указывать компаратор ключей, применять nullsFirst/Last и избегать использования изменяемых полей в качестве единственного критерия.

Изменения и история API

Метод thenComparing() и связанные с ним методы (comparing, thenComparingInt, thenComparingLong, thenComparingDouble, nullsFirst, nullsLast) были введены в Java 8 вместе с функциональными интерфейсами и Stream API. С тех пор сигнатура и поведение остались стабильными, существенных изменений в последующих версиях не происходило. Поддержка улучшений производительности и платформенных оптимизаций происходит в реализации JVM, но публичный API принципиально не изменялся.

Расширенные и нетипичные примеры использования

Несколько продвинутых приёмов и реальных сценариев.

1. Локалезированное сравнение строк с Collator и несколькими уровнями

import java.text.Collator;import java.util.*;
Collator coll = Collator.getInstance(new Locale("ru"));
List<String> names = Arrays.asList("ёлка","е" ,"яблоко","ёлка");
names.sort(Comparator.comparing((String s)> s, (a,b)> coll.compare(a,b)).thenComparing(String::length));
System.out.println(names);

[е, ёлка, ёлка, яблоко]

2. Компаратор с обработкой null в ключе и fallback по индексу для стабильности

import java.util.*;
class Item{String k;int idx;Item(String k,int i){this.k=k;this.idx=i;} public String toString(){return k+"#"+idx;} }
List<Item> L = Arrays.asList(new Item(null,0), new Item("a",1), new Item(null,2));
Comparator<Item> cmp = Comparator.comparing((Item it)>it.k, Comparator.nullsFirst(String::compareTo)).thenComparingInt(it->it.idx);
L.sort(cmp);
System.out.println(L);

[null#0, null#2, a#1]

3. Использование thenComparing для составного ключа из нескольких полей (через mapping)

import java.util.*;
class Point{int x,y;Point(int x,int y){this.x=x;this.y=y;} public String toString(){return "("+x+","+y+")";} }
List<Point> pts = Arrays.asList(new Point(1,2), new Point(1,1), new Point(0,5));
Comparator<Point> cmp = Comparator.comparingInt((Point p)>p.x).thenComparingInt(p->p.y);
pts.sort(cmp);
System.out.println(pts);

[(0,5), (1,1), (1,2)]

4. Комбинирование сложных компараторов: частичная обратная сортировка и null-обработка

import java.util.*;
List<String> arr = Arrays.asList("b", null, "aa", "c");
Comparator<String> cmp = Comparator.nullsLast(Comparator.comparing(String::length).reversed()).thenComparing(Comparator.naturalOrder());
arr.sort(cmp);
System.out.println(arr);

[aa, b, c, null]

5. Использование в TreeSet для поддержания порядка с несколькими уровнями

import java.util.*;
class P{String n;int a;P(String n,int a){this.n=n;this.a=a;} public String toString(){return n+"("+a+")";} }
Comparator<P> cmp = Comparator.comparing((P p)>p.a).thenComparing(p->p.n);
Set<P> set = new TreeSet<>(cmp);
set.add(new P("A",10)); set.add(new P("B",10)); set.add(new P("A",10));
System.out.println(set);

[A(10), B(10)]

В этом примере элементы с одинаковыми значениями по всем критериям считаются равными и в TreeSet дубли отбрасываются.

6. Сложная сортировка в потоке с сохранением исходного порядка в качестве последнего критерия

import java.util.*;import java.util.concurrent.atomic.AtomicInteger;import java.util.stream.Collectors;
class Elem{String t;Elem(String t){this.t=t;} public String toString(){return t;} }
AtomicInteger idx = new AtomicInteger();
List<Elem> list = Arrays.asList(new Elem("b"), new Elem("a"), new Elem("b"));
List<Elem> sorted = IntStream.range(0,list.size())
  .mapToObj(i -> new AbstractMap.SimpleEntry<>(list.get(i), i))
  .sorted(Comparator.comparing((AbstractMap.SimpleEntry<Elem,Integer> e)>e.getKey().toString())
          .thenComparingInt(Map.Entry::getValue))
  .map(Map.Entry::getKey)
  .collect(Collectors.toList());
System.out.println(sorted);

[a, b, b]

В качестве последнего уровня используется индекс, чтобы сохранить стабильность при равных ключах.