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

CKTIS / Java

Comparator — combinar reglas de ordenación

java.util.Comparator describe un orden con independencia de la clase de los objetos. Permite combinar claves, invertir la dirección y tratar null de forma explícita, tanto para los elementos completos como para sus campos.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

Comparator<T> order = Comparator.comparing(keyExtractor, keyComparator).thenComparingInt(intKeyExtractor);
Comparator<T> descending = order.reversed();
Comparator<T> nullable = Comparator.nullsLast(order);

java.util.Comparator<T> define un orden: compare(a, b) devuelve un valor negativo, cero o un valor positivo. La comparación debe ser transitiva. Al intercambiar los argumentos, un resultado distinto de cero debe cambiar de signo; si compare(a, b) devuelve cero, compare(b, a) también debe devolver cero. Si compare(a, b) devuelve cero, para todo z los resultados de compare(a, z) y compare(b, z) deben tener el mismo signo: ambos negativos, ambos iguales a cero o ambos positivos. Cero significa equivalencia en este orden, no necesariamente equals; en TreeSet y TreeMap esto afecta a la unicidad.

Comparator.comparing compara claves extraídas según su orden natural o un comparador proporcionado. Comparator.naturalOrder usa Comparable y rechaza null. Comparator.comparingInt utiliza una clave int sin convertirla en Integer.

Comparator.thenComparing añade un criterio de desempate que solo se usa cuando hay empate; acepta un comparador o un extractor de claves, opcionalmente con un comparador para la clave. Comparator.thenComparingInt añade una clave int. Comparator.reversed invierte todo el orden construido hasta ese momento, así que la posición de la llamada importa.

Comparator.nullsFirst y Comparator.nullsLast colocan null antes o después de los valores no nulos, respectivamente. Envolver el comparador de la clave protege la clave; envolver el orden completo protege el elemento. Invertir un comparador envuelto también invierte la posición de null.

Ejemplos

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    record Item(String name, int score, int id) {}

    public static void main(String[] args) {
        Item[] items = {
            new Item("Ada", 10, 2),
            null,
            new Item(null, 10, 4),
            new Item("Ada", 10, 1),
            new Item("Bob", 20, 3)
        };

        Comparator<Item> byName = Comparator.comparing(
                Item::name,
                Comparator.nullsFirst(Comparator.<String>naturalOrder()));
        Comparator<Item> order = Comparator.comparingInt(Item::score)
                .reversed()
                .thenComparing(byName)
                .thenComparingInt(Item::id);

        Arrays.sort(items, Comparator.nullsLast(order));
        for (Item item : items) {
            System.out.println(item == null ? "null"
                    : item.name() + ":" + item.score() + ":" + item.id());
        }
    }
}

Resultado

Bob:20:3
null:10:4
Ada:10:1
Ada:10:2
null

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes