Teil-Maps und Bereichsansichten
Erstellen Sie mit subMap, headMap und tailMap Ansichten für bereichsbasierte Suchen in sortierten Maps.
Teil-Maps und Bereichsansichten ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Bereichsansichten in TreeMap
Die Methoden subMap, headMap und tailMap von TreeMap geben gebundene Ansichten zurück – sie spiegeln Änderungen in der zugrunde liegenden Map wider und umgekehrt. Änderungen über die Ansicht werden in der ursprünglichen Map sichtbar.
TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 10; i++) map.put(i * 10, "item" + i);
var view = map.subMap(30, 70); // [30, 70)
System.out.println(view); // {30=item3, 40=item4, 50=item5, 60=item6}
map.put(45, "new"); // also visible through view!
System.out.println(view.containsKey(45)); // trueheadMap: Schlüssel unterhalb einer Grenze
headMap(toKey) gibt alle Einträge mit Schlüsseln zurück, die strikt kleiner als toKey sind. Verwenden Sie die inklusive Variante headMap(toKey, true), um die Grenze einzuschließen.
TreeMap<String, Integer> words = new TreeMap<>();
"banana cherry apple date elderberry".chars()
.mapToObj(c -> String.valueOf((char)c)).distinct()
.forEach(w -> words.put(w, w.length()));
// Actually let's use real words:
TreeMap<String, Integer> wc = new TreeMap<>();
wc.put("apple",5); wc.put("banana",6); wc.put("cherry",6); wc.put("date",4);
System.out.println(wc.headMap("cherry")); // {apple=5, banana=6}tailMap: Schlüssel ab einer Grenze
tailMap(fromKey) gibt alle Einträge mit Schlüsseln zurück, die ≥ fromKey sind.
TreeMap<Integer, String> grades = new TreeMap<>();
grades.put(50,"F"); grades.put(60,"D"); grades.put(70,"C"); grades.put(80,"B"); grades.put(90,"A");
// All passing grades (>= 60)
var passing = grades.tailMap(60);
System.out.println(passing); // {60=D, 70=C, 80=B, 90=A}subMap mit inklusiven Grenzen
Mit dem 4-Argumente-Aufruf subMap(from, fromInclusive, to, toInclusive) können Sie die Inklusivität der Grenzen vollständig steuern:
TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 10; i <= 100; i += 10) map.put(i, "v"+i);
// [30, 60] — both inclusive
System.out.println(map.subMap(30, true, 60, true));
// {30=v30, 40=v40, 50=v50, 60=v60}
// (30, 60) — both exclusive
System.out.println(map.subMap(30, false, 60, false));
// {40=v40, 50=v50}Ändern von Daten über eine Ansicht
Put- und Remove-Operationen auf einer subMap-Ansicht werden in der ursprünglichen Map sichtbar (und umgekehrt). Der Versuch, einen Schlüssel außerhalb des Bereichs der Ansicht einzufügen, löst eine Ausnahme aus.
TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 5; i++) map.put(i * 10, "v" + i);
var view = map.subMap(20, 40); // [20, 40)
view.remove(20); // removes from both view and original map
System.out.println(map.containsKey(20)); // false
// This would throw IllegalArgumentException:
// view.put(50, "out of range");Anwendungsfall: Protokoll-Bereichsabfrage
Rufen Sie mithilfe einer TreeMap-Bereichsansicht alle Protokolleinträge zwischen zwei Zeitstempeln ab:
import java.time.*;
TreeMap<LocalDateTime, String> logs = new TreeMap<>();
logs.put(LocalDateTime.of(2024,1,1,8,0), "Server start");
logs.put(LocalDateTime.of(2024,1,1,10,0), "Request spike");
logs.put(LocalDateTime.of(2024,1,1,14,0), "Maintenance");
logs.put(LocalDateTime.of(2024,1,1,18,0), "Server stop");
var morning = logs.subMap(
LocalDateTime.of(2024,1,1,8,0), true,
LocalDateTime.of(2024,1,1,12,0), false
);
morning.forEach((t,m) -> System.out.println(t+" : "+m));Anwendungsfall: Suche in einem Preisbereich
Finden Sie alle Produkte in einem Preisbereich, indem Sie die TreeMap-Schlüssel als Preise verwenden:
TreeMap<Double, String> products = new TreeMap<>();
products.put(9.99, "Pen");
products.put(24.99, "Book");
products.put(49.99, "Headphones");
products.put(299.99, "Tablet");
double min = 10.0, max = 100.0;
var affordable = products.subMap(min, true, max, true);
affordable.forEach((p,n) -> System.out.println(n+" $"+p));
// Book $24.99, Headphones $49.99Absteigende subMap
Verketten Sie descendingMap() mit einer Ansicht, um in umgekehrter Reihenfolge zu navigieren:
TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 10; i <= 100; i += 10) map.put(i, "v"+i);
// Get [40, 80] in descending order
map.subMap(40, true, 80, true)
.descendingMap()
.forEach((k,v) -> System.out.println(k + "=" + v));
// 80=v80, 70=v70, 60=v60, 50=v50, 40=v40NavigableMap-Interface
NavigableMap erweitert SortedMap und ergänzt die Navigation über ceiling-, floor-, higher- und lower-Schlüssel sowie absteigende Ansichten. TreeMap ist die verbreitetste Implementierung; ConcurrentSkipListMap ist die threadsichere Alternative.
Performance von Ansichten
Operationen auf einer Submap-Ansicht (get, put, containsKey) haben wie die zugrunde liegende TreeMap die Komplexität O(log n). Das Erstellen der Ansicht ist O(1) – es wird nichts kopiert. Bereichsdurchläufe über n Schlüssel in der Ansicht haben die Komplexität O(log N + n), wobei N die Größe der vollständigen Map ist.
Stolperfalle: Veraltete Ansichten
Da Ansichten an die ursprüngliche Map gebunden sind, kann eine Ansicht leer werden oder eine Ausnahme auslösen, wenn die ursprüngliche Map geleert wird. Dokumentieren Sie immer, dass Ansichten live sind, und bewahren Sie sie nicht über ihren vorgesehenen Lebenszyklus hinaus auf.
TreeMap<Integer, String> map = new TreeMap<>();
map.put(10, "a"); map.put(20, "b"); map.put(30, "c");
var view = map.subMap(10, 30);
map.clear(); // view becomes empty
System.out.println(view.size()); // 0 — but no exceptionKurzer Test
Sie rufen map.subMap(30, false, 70, true) auf einer TreeMap mit den Schlüsseln {10,20,30,40,50,60,70,80} auf. Welche Schlüssel sind im Ergebnis enthalten?
Zusammenfassung: Submaps und Bereichsansichten
Wichtigste Erkenntnisse:
- subMap, headMap und tailMap geben live gebundene Ansichten zurück – es wird nichts kopiert
- Änderungen in der Ansicht werden in der ursprünglichen Map sichtbar und umgekehrt
- 4-Argumente-subMap(from, fromInclusive, to, toInclusive) für vollständige Kontrolle über die Grenzen
- Put-Operationen außerhalb des Bereichs lösen über eine Ansicht eine IllegalArgumentException aus
- Komplexität eines Bereichsdurchlaufs: O(log N + n)
Häufig gestellte Fragen
Ist die Lektion „Teil-Maps und Bereichsansichten“ kostenlos?
Ja — der vollständige Text von „Teil-Maps und Bereichsansichten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Teil-Maps und Bereichsansichten“?
Erstellen Sie mit subMap, headMap und tailMap Ansichten für bereichsbasierte Suchen in sortierten Maps. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Teil-Maps und Bereichsansichten“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- TreeMap: Sortierte Schlüssel-Wert-Paare
- Teil-Maps und Bereichsansichten
- TreeSet und NavigableSet
- Eigene Ordnung in Tree-Collections