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

CKTIS / Java

Claves extremas de SortedMap: firstKey() y lastKey()

`firstKey()` y `lastKey()` devuelven las claves de los extremos del orden del mapa. Ambos métodos lanzan `NoSuchElementException` si el mapa está vacío.

Versión: Java SE 21

Sintaxis

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

En java.util.SortedMap<K,V>, firstKey() devuelve la primera clave y lastKey() la última. Ambos métodos se llaman sin argumentos, devuelven una clave de tipo K en vez de un valor o una entrada clave-valor y no eliminan ninguna entrada.

La primera clave viene determinada por el orden de las claves del mapa: el orden natural si comparator() devuelve null, o el definido por el comparador en caso contrario. El orden de inserción no importa. Para 10, 70 y 120, el orden natural sitúa 10 al principio y 120 al final. Con Comparator.reverseOrder() sucede lo contrario: 120 queda primero y 10 último.

En un mapa vacío, cualquiera de las dos llamadas lanza NoSuchElementException en lugar de devolver null. Si el mapa no puede cambiar entre la comprobación y la consulta, puedes llamar primero a isEmpty(). En Java SE 21, SortedMap también hereda de SequencedMap los métodos firstEntry() y lastEntry(): devuelven una entrada Map.Entry<K,V> o null si el mapa está vacío.

Ejemplos

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

Las líneas esperadas `natural: 10/120` y `reverse: 120/10` muestran el efecto del comparador. Las dos últimas corresponden a las excepciones capturadas por separado en el mapa vacío.

Lecciones relacionadas

  • Java · Lección 20 · Avanzado · Versión: 2

Fuentes