Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Chiavi adiacenti in NavigableMap

Trova la chiave memorizzata più vicina al di sotto o al di sopra della chiave cercata, ammettendo o meno l’uguaglianza.

Versione: Java SE 21

Sintassi

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

I metodi di java.util.NavigableMap<K, V> cercano tra le chiavi memorizzate. La chiave di ricerca q non deve essere necessariamente presente nella mappa. lowerKey(q) restituisce la chiave più grande < q, floorKey(q) la chiave più grande <= q, ceilingKey(q) la chiave più piccola >= q e higherKey(q) la chiave più piccola > q.

Queste relazioni seguono l’ordinamento della mappa: quello naturale delle chiavi oppure quello definito da un Comparator. Ai fini della ricerca, due chiavi sono uguali se il confronto restituisce 0. In questo caso floorKey e ceilingKey possono restituire la chiave memorizzata, mentre lowerKey e higherKey la escludono.

Questi metodi restituiscono solo una chiave di tipo K, non un valore né una coppia chiave-valore. Se nessuna chiave soddisfa la condizione, anche quando la mappa è vuota, il risultato è null. Se la mappa ammette null come chiave, quel risultato può anche indicare che è stata trovata proprio quella chiave. Per ottenere chiave e valore o distinguere i due casi, usa il metodo corrispondente lowerEntry, floorEntry, ceilingEntry o higherEntry: restituisce un Map.Entry<K, V> se trova una corrispondenza, altrimenti null.

Non trovare una chiave non equivale a passare un argomento non valido: un argomento null può causare una NullPointerException se la mappa non ammette chiavi null. Per esempio, in JDK 21, su una TreeMap vuota con ordinamento naturale tutti e quattro i metodi restituiscono null anche se l’argomento è null, perché non c’è alcuna chiave memorizzata con cui confrontarlo. Una chiave che non si può confrontare con quelle della mappa causa una ClassCastException.

Esempi

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));
    }
}

Risultato

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

I risultati vengono stampati nell’ordine `lowerKey`, `floorKey`, `ceilingKey`, `higherKey`. Per `75` si ottiene `50 / 50 / 90 / 90`. Per la chiave memorizzata `50`, solo i metodi che ammettono l’uguaglianza restituiscono `50`. Non ci sono chiavi sotto `10` né sopra `90`, quindi gli ultimi due risultati sono `null`.

Lezioni correlate

  • Java · Lezione 20 · Avanzato · Versione: 2

Fonti