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

CKTIS / Java

Chaves nos extremos de SortedMap: firstKey() e lastKey()

`firstKey()` e `lastKey()` devolvem as chaves nos extremos da ordenação do mapa. Ambos lançam `NoSuchElementException` se o mapa estiver vazio.

Versão: Java SE 21

Sintaxe

In java.util.SortedMap<K,V>:
K firstKey();
K lastKey();

Em java.util.SortedMap<K,V>, firstKey() devolve a primeira chave e lastKey() devolve a última. Nenhum dos métodos recebe argumentos. Ambos devolvem uma chave de tipo K, e não um valor nem uma entrada chave–valor, e não removem entradas.

A primeira chave é determinada pela ordenação das chaves do mapa: a ordem natural se comparator() devolver null, ou a ordem definida pelo comparador caso contrário. A ordem de inserção não interessa. Para as chaves 10, 70 e 120, a ordem natural põe 10 em primeiro lugar e 120 em último. Com Comparator.reverseOrder() acontece o contrário: 120 fica em primeiro lugar e 10 em último.

Num mapa vazio, qualquer uma das chamadas lança NoSuchElementException em vez de devolver null. Se o mapa não puder mudar entre a verificação e a leitura, podes chamar isEmpty() primeiro. Em Java SE 21, SortedMap também herda de SequencedMap os métodos firstEntry() e lastEntry(): devolvem uma entrada Map.Entry<K,V> ou null se o mapa estiver vazio.

Exemplos

import java.util.Comparator;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        SortedMap<Integer, String> natural = new TreeMap<>();
        natural.put(70, "middle");
        natural.put(120, "high");
        natural.put(10, "low");

        SortedMap<Integer, String> reverse = new TreeMap<>(Comparator.reverseOrder());
        reverse.putAll(natural);

        System.out.println("natural: " + natural.firstKey() + "/" + natural.lastKey());
        System.out.println("reverse: " + reverse.firstKey() + "/" + reverse.lastKey());

        SortedMap<Integer, String> empty = new TreeMap<>();
        expectEmptyFailure("firstKey", empty::firstKey);
        expectEmptyFailure("lastKey", empty::lastKey);
    }

    private static void expectEmptyFailure(String method, Runnable call) {
        try {
            call.run();
        } catch (NoSuchElementException expected) {
            System.out.println(method + ": NoSuchElementException");
            return;
        }
        throw new AssertionError(method + " did not throw NoSuchElementException");
    }
}

Resultado

natural: 10/120
reverse: 120/10
firstKey: NoSuchElementException
lastKey: NoSuchElementException

As linhas esperadas `natural: 10/120` e `reverse: 120/10` mostram o efeito do comparador. As duas últimas correspondem às exceções capturadas separadamente no mapa vazio.

Lições relacionadas

  • Java · Lição 20 · Avançado · Versão: 2

Fontes