Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Comparator.comparing — comparar objetos por uma chave

Cria um comparador de objetos a partir de uma chave. Usa a ordem natural das chaves ou fornece um comparador que defina a sua ordem, incluindo a posição das chaves `null`.

Versão: Java SE 21

Sintaxe

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)

Em Java SE 21, Comparator.comparing é um método estático da interface java.util.Comparator. A notação Comparator.comparing() identifica o método no texto; não é uma chamada válida sem argumentos. O método devolve um Comparator<T> e não ordena nada por si só. Ao comparar dois objetos do tipo T, o comparador devolvido extrai de cada um uma chave do tipo U e compara essas chaves.

A sobrecarga com um argumento usa a ordem natural das chaves, pelo que U tem de implementar Comparable<? super U>. A referência ao método Ticket::getId serve para extrair a chave: dado um Ticket, devolve o seu identificador do tipo String. A ordem natural de String é lexicográfica, não numérica, por isso T10 vem antes de T2.

A sobrecarga com dois argumentos usa o comparador fornecido para as chaves e não exige que U implemente Comparable. Em ambas as sobrecargas, passar null como argumento do método provoca uma NullPointerException. Uma chave devolvida pela função de extração é um caso diferente: a sobrecarga com um argumento não aceita chaves null. Na sobrecarga com dois argumentos, Comparator.nullsLast(Comparator.naturalOrder()) coloca as chaves null depois das restantes. Isto não protege contra um elemento null na lista: Ticket::getId continuaria a tentar chamar um método sobre null. Se os elementos também puderem ser null, envolve o comparador de objetos Ticket por inteiro em Comparator.nullsLast.

Exemplos

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` que altera a ordem da lista. A primeira ordenação usa a ordem natural dos identificadores `String`. Antes da segunda ordenação, é inserido no início um `Ticket` com identificador `null`; a segunda ordenação move-o para o fim.

Lições relacionadas

  • Java · Lição 42 · Básico · Versão: 2
  • Java · Lição 48 · Básico · Versão: 2
  • Java · Lição 35 · Intermédio · Versão: 2

Fontes