WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Benachbarte Schlüssel in NavigableMap

Finde den nächsten gespeicherten Schlüssel unterhalb oder oberhalb eines Suchschlüssels, je nach Methode mit oder ohne Gleichheit.

Version: Java SE 21

Syntax

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

Die Methoden von java.util.NavigableMap<K, V> suchen nach gespeicherten Schlüsseln. Der Suchschlüssel q muss nicht in der Map stehen. lowerKey(q) liefert den größten Schlüssel < q, floorKey(q) den größten Schlüssel <= q, ceilingKey(q) den kleinsten Schlüssel >= q und higherKey(q) den kleinsten Schlüssel > q.

Maßgeblich ist die Reihenfolge der Map: die natürliche Ordnung der Schlüssel oder die von einem Comparator festgelegte Ordnung. Für die Suche gelten Schlüssel als gleich, wenn der Vergleich 0 ergibt. floorKey und ceilingKey können dann den gespeicherten Schlüssel liefern; lowerKey und higherKey überspringen ihn.

Die Methoden liefern nur einen Schlüssel vom Typ K, keinen Wert und kein Schlüssel-Wert-Paar. Gibt es keinen passenden Schlüssel, etwa bei einer leeren Map, ist das Ergebnis null. Lässt die Map null als Schlüssel zu, kann dieses Ergebnis auch bedeuten, dass der Schlüssel null gefunden wurde. Wer Schlüssel und Wert benötigt oder beide Fälle unterscheiden will, verwendet die entsprechende Methode lowerEntry, floorEntry, ceilingEntry oder higherEntry: Bei einem Treffer liefert sie ein Map.Entry<K, V>, sonst null.

Kein Treffer ist nicht dasselbe wie ein ungültiges Argument: Ist null als Schlüssel unzulässig, kann das Argument null zu einer NullPointerException führen. Bei einer leeren TreeMap mit natürlicher Schlüsselordnung liefern in JDK 21 jedoch alle vier Methoden auch für das Argument null den Wert null, weil es keinen gespeicherten Schlüssel zum Vergleichen gibt. Ist ein Schlüssel nicht mit den Schlüsseln in der Map vergleichbar, führt das zu einer ClassCastException.

Beispiele

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

Ergebnis

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

Die Ausgabe folgt der Reihenfolge `lowerKey`, `floorKey`, `ceilingKey`, `higherKey`. Für `75` ergibt sich `50 / 50 / 90 / 90`. Beim gespeicherten Schlüssel `50` liefern nur die Methoden, die Gleichheit zulassen, `50`. Unterhalb von `10` und oberhalb von `90` gibt es keinen Nachbarn; daher lauten die letzten beiden Ergebnisse `null`.

Zugehörige Lektionen

  • Java · Lektion 20 · Fortgeschritten · Version: 2

Quellen