0Pricing
Java Academy · Lektion

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)); // true

headMap: 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.99

Absteigende 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=v40

NavigableMap-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 exception

Kurzer 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

  1. TreeMap: Sortierte Schlüssel-Wert-Paare
  2. Teil-Maps und Bereichsansichten
  3. TreeSet und NavigableSet
  4. Eigene Ordnung in Tree-Collections
← Zurück zu Java Academy