CKTIS / Java
Comparator.thenComparing — acrescentar um critério de desempate
Combine critérios de ordenação para que o critério seguinte só seja usado quando os anteriores não distinguem dois elementos.
Versão: Java SE 21
Sintaxe
import java.util.Comparator;
import java.util.function.Function;
// Signatures of the default methods on Comparator<T>:
default Comparator<T> thenComparing(Comparator<? super T> other)
default <U extends Comparable<? super U>> Comparator<T> thenComparing(Function<? super T, ? extends U> keyExtractor)
default <U> Comparator<T> thenComparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)
// Example call on a Comparator<Person>:
byAge.thenComparing(Person::lastName)Comparator.thenComparing designa vários métodos predefinidos de java.util.Comparator, disponíveis desde o Java 8 e incluídos no Java SE 21. Comparator.thenComparing() é uma forma abreviada de indicar o método, não uma sobrecarga sem argumentos. A chamada sobre um comparador existente devolve um comparador composto. O comparador original não é alterado e a chamada, por si só, não ordena nada.
Para um par a e b, o critério seguinte só é usado se o compare(a, b) do comparador anterior devolver 0. É um empate para o comparador, não necessariamente uma igualdade segundo equals. Numa cadeia, o terceiro critério só intervém se houver empate nos dois primeiros. Se houver empate em todos os critérios, o comparador composto devolve 0 e a ordenação estável de List.sort mantém a ordem relativa do par.
thenComparing(other) delega a comparação dos mesmos elementos noutro comparador. thenComparing(keyExtractor) extrai uma chave Comparable de cada elemento e compara as chaves pela sua ordem natural. thenComparing(keyExtractor, keyComparator) compara as chaves extraídas com o comparador fornecido; as chaves não têm de implementar Comparable.
Passar null em qualquer argumento lança uma NullPointerException. Isto é diferente de a função de extração devolver uma chave null: a sobrecarga que usa a ordem natural não aceita essas chaves. Se forem possíveis, pode fornecer um comparador de chaves como Comparator.nullsLast(Comparator.naturalOrder()). Para chaves de tipo primitivo, thenComparingInt, thenComparingLong e thenComparingDouble evitam o boxing.
Exemplos
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
public class Main {
record Person(int age, String lastName) {}
public static void main(String[] args) {
List<Person> people = new ArrayList<>(List.of(
new Person(21, "Smith"),
new Person(30, "Adams"),
new Person(21, "Brown")
));
Comparator<Person> byAge = Comparator.comparingInt(Person::age);
Comparator<Person> byAgeThenLastName = byAge.thenComparing(Person::lastName);
people.sort(byAgeThenLastName);
for (Person person : people) {
System.out.println(person.age() + " " + person.lastName());
}
}
}Resultado
21 Brown 21 Smith 30 Adams
`Comparator.comparingInt(Person::age)` ordena as pessoas por idade crescente. `Person::lastName` desempata as duas pessoas de 21 anos: Brown fica antes de Smith. Adams fica em último devido à idade, embora na ordem natural das cadeias de caracteres Adams ficasse em primeiro.
Lições relacionadas
- Java · Lição 8 · Avançado · Versão: 2
- Java · Lição 48 · Básico · Versão: 2
- Java · Lição 35 · Intermédio · Versão: 2