CKTIS / Java
Comparator.comparing — comparar objetos por una clave
Crea un comparador de objetos a partir de una clave. Usa el orden natural de las claves o proporciona un comparador que defina su orden, incluida la posición de las claves `null`.
Versión: Java SE 21
Sintaxis
import java.util.Comparator;
import java.util.function.Function;
// Static method signatures on java.util.Comparator (Java SE 21)
static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor)
static <T, U> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)En Java SE 21, Comparator.comparing es un método estático de la interfaz java.util.Comparator. La notación Comparator.comparing() nombra el método en un texto, pero no es una llamada válida sin argumentos. El método devuelve un Comparator<T> y no ordena nada por sí mismo. Al comparar dos objetos de tipo T, el comparador devuelto extrae de cada uno una clave de tipo U y compara esas claves.
La sobrecarga de un argumento usa el orden natural de las claves, por lo que U debe implementar Comparable<? super U>. La referencia a método Ticket::getId sirve para extraer la clave: dado un Ticket, devuelve su identificador de tipo String. El orden natural de String es lexicográfico, no numérico, así que T10 va antes que T2.
La sobrecarga de dos argumentos usa el comparador proporcionado para las claves y no exige que U implemente Comparable. En ambas sobrecargas, pasar null como argumento del método provoca una NullPointerException. Una clave devuelta por la función de extracción es otra cosa: la sobrecarga de un argumento no admite claves null. Con la de dos argumentos, Comparator.nullsLast(Comparator.naturalOrder()) coloca las claves null después de las demás. Esto no protege frente a un elemento null en la lista: Ticket::getId seguiría intentando llamar a un método sobre null. Si los elementos también pueden ser null, envuelve el comparador de objetos Ticket completo con Comparator.nullsLast.
Ejemplos
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.StringJoiner;
public class Main {
static final class Ticket {
private final String id;
Ticket(String id) {
this.id = id;
}
String getId() {
return id;
}
}
private static void printIds(List<Ticket> tickets) {
StringJoiner ids = new StringJoiner(", ", "[", "]");
for (Ticket ticket : tickets) {
ids.add(String.valueOf(ticket.getId()));
}
System.out.println(ids.toString());
}
public static void main(String[] args) {
List<Ticket> tickets = new ArrayList<>(List.of(
new Ticket("T2"), new Ticket("T10")));
Comparator<Ticket> byId = Comparator.comparing(Ticket::getId);
tickets.sort(byId);
printIds(tickets);
tickets.add(0, new Ticket(null));
Comparator<Ticket> byIdNullsLast = Comparator.comparing(
Ticket::getId, Comparator.nullsLast(Comparator.naturalOrder()));
tickets.sort(byIdNullsLast);
printIds(tickets);
}
}Resultado
[T10, T2] [T10, T2, null]
`List.sort` cambia el orden de los elementos. La primera ordenación usa el orden natural de los identificadores `String`. Antes de la segunda se inserta al principio un `Ticket` con identificador `null`; la segunda ordenación lo mueve al final.
Lecciones relacionadas
- Java · Lección 42 · Básico · Versión: 2
- Java · Lección 48 · Básico · Versión: 2
- Java · Lección 35 · Intermedio · Versión: 2