Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Comparator.thenComparing — añadir un criterio de desempate

Combina criterios de ordenación para que el siguiente solo se use si los anteriores no determinan el orden de un par de elementos.

Versión: Java SE 21

Sintaxis

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 varios métodos predeterminados de java.util.Comparator, disponibles desde Java 8 e incluidos en Java SE 21. Comparator.thenComparing() es una forma abreviada de nombrar el método, no una sobrecarga sin argumentos. Al invocarlo sobre un comparador existente, obtienes un comparador compuesto. El comparador original no cambia y la llamada por sí sola no ordena nada.

Para un par a y b, el siguiente criterio solo se aplica si el compare(a, b) del comparador anterior devuelve 0. Es un empate según el comparador, no necesariamente una igualdad según equals. En una cadena, el tercer criterio solo interviene si los dos primeros dan empate. Si todos los criterios empatan, el comparador compuesto devuelve 0 y la ordenación estable de List.sort mantiene el orden relativo del par.

thenComparing(other) delega la comparación de los mismos elementos en otro comparador. thenComparing(keyExtractor) extrae una clave Comparable de cada elemento y compara las claves según su orden natural. thenComparing(keyExtractor, keyComparator) compara las claves extraídas con el comparador proporcionado; no hace falta que las claves implementen Comparable.

Pasar null en cualquier argumento provoca una NullPointerException. Es distinto de que la función de extracción devuelva una clave null: la sobrecarga de orden natural no admite esas claves. Si pueden aparecer, puedes proporcionar un comparador de claves como Comparator.nullsLast(Comparator.naturalOrder()). Para claves primitivas, thenComparingInt, thenComparingLong y thenComparingDouble evitan el boxing.

Ejemplos

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 a las personas por edad ascendente. `Person::lastName` desempata entre las dos personas de 21 años: Brown aparece antes que Smith. Adams queda al final por su edad, aunque en el orden natural de las cadenas Adams aparecería primero.

Lecciones relacionadas

  • Java · Lección 8 · Avanzado · Versión: 2
  • Java · Lección 48 · Básico · Versión: 2
  • Java · Lección 35 · Intermedio · Versión: 2

Fuentes