Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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

Sources