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