CKTIS / Java
Clés voisines dans NavigableMap
Trouve la clé enregistrée la plus proche en dessous ou au-dessus d’une clé recherchée, en autorisant ou non l’égalité.
Version : Java SE 21
Syntaxe
K lowerKey(K key);
K floorKey(K key);
K ceilingKey(K key);
K higherKey(K key);Les méthodes de java.util.NavigableMap<K, V> recherchent des clés déjà enregistrées. La clé recherchée q n’a pas besoin d’être présente dans la map. lowerKey(q) renvoie la plus grande clé < q, floorKey(q) la plus grande clé <= q, ceilingKey(q) la plus petite clé >= q et higherKey(q) la plus petite clé > q.
Ces relations suivent l’ordre de la map : l’ordre naturel des clés ou celui défini par un Comparator. Pour la recherche, deux clés sont considérées comme égales si la comparaison renvoie 0. floorKey et ceilingKey peuvent alors renvoyer la clé enregistrée, tandis que lowerKey et higherKey l’ignorent.
Ces méthodes renvoient uniquement une clé de type K, ni une valeur ni une paire clé-valeur. Si aucune clé ne convient, notamment si la map est vide, le résultat est null. Si la map accepte null comme clé, ce résultat peut aussi signifier que cette clé a été trouvée. Pour obtenir la clé et sa valeur ou distinguer ces deux cas, utilise la méthode correspondante lowerEntry, floorEntry, ceilingEntry ou higherEntry : elle renvoie un Map.Entry<K, V> si une clé convient, et null sinon.
L’absence de résultat n’est pas une erreur d’argument : passer null peut provoquer une NullPointerException si la map n’accepte pas les clés null. Par exemple, dans JDK 21, sur une TreeMap vide qui utilise l’ordre naturel des clés, les quatre méthodes renvoient null même si l’argument est null, car il n’y a aucune clé enregistrée à laquelle le comparer. Une clé qui ne peut pas être comparée aux clés de la map provoque une ClassCastException.
Exemples
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));
}
}Résultat
75: 50 / 50 / 90 / 90 50: 10 / 50 / 50 / 90 lowerKey(10): null higherKey(90): null
Les résultats sont affichés dans l’ordre `lowerKey`, `floorKey`, `ceilingKey`, `higherKey`. Pour `75`, on obtient `50 / 50 / 90 / 90`. Pour la clé enregistrée `50`, seules les méthodes qui autorisent l’égalité renvoient `50`. Il n’y a pas de voisin sous `10` ni au-dessus de `90` : les deux derniers résultats sont `null`.
Leçons associées
- Java · Leçon 20 · Avancé · Version : 2