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

CKTIS / Java

Claves vecinas en NavigableMap

Encuentra la clave almacenada más cercana por debajo o por encima de la buscada, con o sin admitir la igualdad.

Versión: Java SE 21

Sintaxis

K lowerKey(K key);
K floorKey(K key);
K ceilingKey(K key);
K higherKey(K key);

Los métodos de java.util.NavigableMap<K, V> buscan claves almacenadas. La clave de búsqueda q no tiene por qué estar en el mapa. lowerKey(q) devuelve la mayor clave < q, floorKey(q) la mayor clave <= q, ceilingKey(q) la menor clave >= q y higherKey(q) la menor clave > q.

Estas relaciones siguen el orden del mapa: el orden natural de las claves o el que define un Comparator. Para la búsqueda, dos claves se consideran iguales si la comparación devuelve 0. En ese caso, floorKey y ceilingKey pueden devolver la clave almacenada, mientras que lowerKey y higherKey la omiten.

Estos métodos devuelven solo una clave de tipo K, no un valor ni un par clave-valor. Si ninguna clave cumple la condición, incluso si el mapa está vacío, el resultado es null. Si el mapa admite null como clave, ese resultado también puede indicar que se ha encontrado dicha clave. Para obtener la clave y su valor o distinguir ambos casos, usa el método correspondiente: lowerEntry, floorEntry, ceilingEntry o higherEntry. Devuelve un Map.Entry<K, V> si hay coincidencia y null si no la hay.

No encontrar una clave no equivale a pasar un argumento no válido: un argumento null puede provocar NullPointerException si el mapa no admite claves null. Por ejemplo, en JDK 21, los cuatro métodos devuelven null en un TreeMap vacío con orden natural incluso si el argumento es null, porque no hay ninguna clave almacenada con la que compararlo. Una clave que no se puede comparar con las del mapa provoca ClassCastException.

Ejemplos

import java.util.NavigableMap;
import java.util.TreeMap;

public class NeighborKeys {
    public static void main(String[] args) {
        NavigableMap<Integer, String> map = new TreeMap<>();
        map.put(10, "A");
        map.put(50, "B");
        map.put(90, "C");

        printNeighbors(map, 75);
        printNeighbors(map, 50);
        System.out.println("lowerKey(10): " + map.lowerKey(10));
        System.out.println("higherKey(90): " + map.higherKey(90));
    }

    private static void printNeighbors(NavigableMap<Integer, String> map, int key) {
        System.out.println(key + ": " + map.lowerKey(key) + " / " + map.floorKey(key)
                + " / " + map.ceilingKey(key) + " / " + map.higherKey(key));
    }
}

Resultado

75: 50 / 50 / 90 / 90
50: 10 / 50 / 50 / 90
lowerKey(10): null
higherKey(90): null

Los resultados se imprimen en el orden `lowerKey`, `floorKey`, `ceilingKey`, `higherKey`. Para `75` son `50 / 50 / 90 / 90`. Para la clave almacenada `50`, solo los métodos que admiten la igualdad devuelven `50`. No hay una clave vecina por debajo de `10` ni por encima de `90`, así que los dos últimos resultados son `null`.

Lecciones relacionadas

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

Fuentes