Zur Implementierung wird die TreeMap in Java verwendet Kartenschnittstelle und NavigableMap zusammen mit der AbstractMap-Klasse. Die Karte wird nach der natürlichen Reihenfolge ihrer Schlüssel oder nach a sortiert Komparator Wird zum Zeitpunkt der Kartenerstellung bereitgestellt, je nachdem, welcher Konstruktor verwendet wird. Dies erweist sich als effiziente Methode zum Sortieren und Speichern der Schlüssel-Wert-Paare. Die von der Treemap verwaltete Speicherreihenfolge muss wie bei jeder anderen sortierten Map mit „equals“ konsistent sein, unabhängig von den expliziten Komparatoren. Die Treemap-Implementierung ist nicht in dem Sinne synchronisiert, dass, wenn mehrere Threads gleichzeitig auf eine Map zugreifen und mindestens einer der Threads die Map strukturell ändert, sie extern synchronisiert werden muss.
Die TreeMap in Java ist eine konkrete Implementierung der java.util.SortedMap-Schnittstelle. Es stellt eine geordnete Sammlung von Schlüssel-Wert-Paaren bereit, wobei die Schlüssel basierend auf ihrer natürlichen Reihenfolge oder einem benutzerdefinierten Komparator, der an den Konstruktor übergeben wird, geordnet werden.
Eine TreeMap wird mithilfe eines Rot-Schwarz-Baums implementiert, einer Art selbstausgleichender binärer Suchbaum. Dies bietet eine effiziente Leistung für häufige Vorgänge wie das Hinzufügen, Entfernen und Abrufen von Elementen mit einer durchschnittlichen Zeitkomplexität von O(log n).
Hier ist ein Beispiel für die Verwendung der TreeMap-Klasse:
Java
import> java.util.Map;> import> java.util.TreeMap;> public> class> Main {> >public> static> void> main(String[] args) {> >Map treeMap =>new> TreeMap();> >// Adding elements to the tree map> >treeMap.put(>'A'>,>1>);> >treeMap.put(>'C'>,>3>);> >treeMap.put(>'B'>,>2>);> >// Getting values from the tree map> >int> valueA = treeMap.get(>'A'>);> >System.out.println(>'Value of A: '> + valueA);> >// Removing elements from the tree map> >treeMap.remove(>'B'>);> >// Iterating over the elements of the tree map> >for> (String key : treeMap.keySet()) {> >System.out.println(>'Key: '> + key +>', Value: '> + treeMap.get(key));> >}> >}> }> |
>
>Ausgabe
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Funktionen einer TreeMap
Einige wichtige Funktionen der Treemap sind wie folgt:
- Diese Klasse ist Mitglied der Java-Sammlungen Rahmen.
- Die Klasse implementiert Kartenschnittstellen einschließlich NavigableMap , SortedMap und erweitert die AbstractMap-Klasse.
- TreeMap in Java erlaubt keine Nullschlüssel (wie Map) und daher wird eine NullPointerException ausgelöst. Allerdings können mehreren Nullwerten unterschiedliche Schlüssel zugeordnet werden.
- Von den Methoden in dieser Klasse und ihren Ansichten zurückgegebene Eintragspaare stellen Momentaufnahmen von Zuordnungen zum Zeitpunkt ihrer Erstellung dar. Sie unterstützen die Methode Entry.setValue nicht.
Lassen Sie uns nun weitermachen und Synchronized TreeMap besprechen. Die Implementierung einer TreeMap ist nicht synchronisiert. Das heißt, wenn mehrere Threads gleichzeitig auf einen Baumsatz zugreifen und mindestens einer der Threads den Satz ändert, muss er extern synchronisiert werden. Dies wird normalerweise mithilfe der Collections.synchronizedSortedMap-Methode erreicht. Dies geschieht am besten zum Zeitpunkt der Erstellung, um einen versehentlichen unsynchronisierten Zugriff auf das Set zu verhindern. Dies kann wie folgt erfolgen:
SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));>
Geeks, jetzt fragen Sie sich bestimmt, wie die TreeMap intern funktioniert?
Die Methoden in einer TreeMap geben beim Abrufen von Schlüsselsätzen und Werten einen Iterator zurück, der von Natur aus ausfallsicher ist. Daher löst jede gleichzeitige Änderung eine ConcurrentModificationException aus. Eine TreeMap basiert auf einer rot-schwarzen Baumdatenstruktur.
Jeder Knoten im Baum hat:
- 3 Variablen ( K-Taste=Schlüssel, V-Wert=Wert, boolesche Farbe=Farbe )
- 3 Referenzen ( Eintrag links = Links, Eintrag rechts = Rechts, Eintrag übergeordnetes Element = übergeordnetes Element )
Konstruktoren in TreeMap
Um eine TreeMap zu erstellen, müssen wir ein Objekt der TreeMap-Klasse erstellen. Die TreeMap-Klasse besteht aus verschiedenen Konstruktoren, die die mögliche Erstellung der TreeMap ermöglichen. Die folgenden Konstruktoren sind in dieser Klasse verfügbar:
- TreeMap()
- TreeMap(Comparator comp)
- TreeMap(Karte M)
- TreeMap(SortedMap sm)
Lassen Sie uns sie einzeln besprechen und jeden Konstruktor wie folgt implementieren:
Konstruktor 1: TreeMap()
Mit diesem Konstruktor wird eine leere Baumkarte erstellt, die anhand der natürlichen Reihenfolge ihrer Schlüssel sortiert wird.
Beispiel
Java
// Java Program to Demonstrate TreeMap> // using the Default Constructor> // Importing required classes> import> java.util.*;> import> java.util.concurrent.*;> // Main class> // TreeMapImplementation> public> class> GFG {> >// Method 1> >// To show TreeMap constructor> >static> void> Example1stConstructor()> >{> >// Creating an empty TreeMap> >TreeMap tree_map> >=>new> TreeMap();> >// Mapping string values to int keys> >// using put() method> >tree_map.put(>10>,>'Geeks'>);> >tree_map.put(>15>,>'4'>);> >tree_map.put(>20>,>'Geeks'>);> >tree_map.put(>25>,>'Welcomes'>);> >tree_map.put(>30>,>'You'>);> >// Printing the elements of TreeMap> >System.out.println(>'TreeMap: '> + tree_map);> >}> >// Method 2> >// Main driver method> >public> static> void> main(String[] args)> >{> >System.out.println(>'TreeMap using '> >+>'TreeMap() constructor:
'>);> >// Calling constructor> >Example1stConstructor();> >}> }> |
>
>Ausgabe
TreeMap using TreeMap() constructor: TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You}> Konstruktor 2: TreeMap(Comparator comp)
Mit diesem Konstruktor wird ein leeres TreeMap-Objekt erstellt, in dem die Elemente eine externe Angabe der Sortierreihenfolge benötigen.
Beispiel
Java
// Java Program to Demonstrate TreeMap> // using Comparator Constructor> // Importing required classes> import> java.util.*;> import> java.util.concurrent.*;> // Class 1> // Helper class representing Student> class> Student {> >// Attributes of a student> >int> rollno;> >String name, address;> >// Constructor> >public> Student(>int> rollno, String name, String address)> >{> >// This keyword refers to current object itself> >this>.rollno = rollno;> >this>.name = name;> >this>.address = address;> >}> >// Method of this class> >// To print student details> >public> String toString()> >{> >return> this>.rollno +>' '> +>this>.name +>' '> >+>this>.address;> >}> }> // Class 2> // Helper class - Comparator implementation> class> Sortbyroll>implements> Comparator {> >// Used for sorting in ascending order of> >// roll number> >public> int> compare(Student a, Student b)> >{> >return> a.rollno - b.rollno;> >}> }> // Class 3> // Main class> public> class> GFG {> >// Calling constructor inside main()> >static> void> Example2ndConstructor()> >{> >// Creating an empty TreeMap> >TreeMap tree_map> >=>new> TreeMap(> >new> Sortbyroll());> >// Mapping string values to int keys> >tree_map.put(>new> Student(>111>,>'bbbb'>,>'london'>),>2>);> >tree_map.put(>new> Student(>131>,>'aaaa'>,>'nyc'>),>3>);> >tree_map.put(>new> Student(>121>,>'cccc'>,>'jaipur'>),>1>);> >// Printing the elements of TreeMap> >System.out.println(>'TreeMap: '> + tree_map);> >}> >// Main driver method> >public> static> void> main(String[] args)> >{> >System.out.println(>'TreeMap using '> >+>'TreeMap(Comparator)'> >+>' constructor:
'>);> >Example2ndConstructor();> >}> }> |
>
>Ausgabe
TreeMap using TreeMap(Comparator) constructor: TreeMap: {111 bbbb london=2, 121 cccc jaipur=1, 131 aaaa nyc=3}> Konstruktor 3: TreeMap(Karte M)
Dieser Konstruktor wird verwendet, um eine TreeMap mit den Einträgen aus der angegebenen Karte M zu initialisieren, die anhand der natürlichen Reihenfolge der Schlüssel sortiert werden.
Beispiel
Java
// Java Program to Demonstrate TreeMap> // using the Default Constructor> // Importing required classes> import> java.util.*;> import> java.util.concurrent.*;> // Main class> public> class> TreeMapImplementation {> >// Method 1> >// To illustrate constructor> >static> void> Example3rdConstructor()> >{> >// Creating an empty HashMap> >Map hash_map> >=>new> HashMap();> >// Mapping string values to int keys> >// using put() method> >hash_map.put(>10>,>'Geeks'>);> >hash_map.put(>15>,>'4'>);> >hash_map.put(>20>,>'Geeks'>);> >hash_map.put(>25>,>'Welcomes'>);> >hash_map.put(>30>,>'You'>);> >// Creating the TreeMap using the Map> >TreeMap tree_map> >=>new> TreeMap(hash_map);> >// Printing the elements of TreeMap> >System.out.println(>'TreeMap: '> + tree_map);> >}> >// Method 2> >// Main driver method> >public> static> void> main(String[] args)> >{> >System.out.println(>'TreeMap using '> >+>'TreeMap(Map)'> >+>' constructor:
'>);> >Example3rdConstructor();> >}> }> |
>
>Ausgabe
TreeMap using TreeMap(Map) constructor: TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You}> Konstruktor 4: TreeMap(SortedMap sm)
Dieser Konstruktor wird verwendet, um eine TreeMap mit den Einträgen aus der angegebenen sortierten Karte zu initialisieren, die in derselben Reihenfolge wie die angegebene sortierte Karte gespeichert werden.
Beispiel
Java
// Java Program to Demonstrate TreeMap> // using the SortedMap Constructor> // Importing required classes> import> java.util.*;> import> java.util.concurrent.*;> // Main class> // TreeMapImplementation> public> class> GFG {> >// Method> >// To show TreeMap(SortedMap) constructor> >static> void> Example4thConstructor()> >{> >// Creating a SortedMap> >SortedMap sorted_map> >=>new> ConcurrentSkipListMap();> >// Mapping string values to int keys> >// using put() method> >sorted_map.put(>10>,>'Geeks'>);> >sorted_map.put(>15>,>'4'>);> >sorted_map.put(>20>,>'Geeks'>);> >sorted_map.put(>25>,>'Welcomes'>);> >sorted_map.put(>30>,>'You'>);> >// Creating the TreeMap using the SortedMap> >TreeMap tree_map> >=>new> TreeMap(sorted_map);> >// Printing the elements of TreeMap> >System.out.println(>'TreeMap: '> + tree_map);> >}> >// Method 2> >// Main driver method> >public> static> void> main(String[] args)> >{> >System.out.println(>'TreeMap using '> >+>'TreeMap(SortedMap)'> >+>' constructor:
'>);> >Example4thConstructor();> >}> }> |
>
>Ausgabe
TreeMap using TreeMap(SortedMap) constructor: TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You}> Methoden in der TreeMap-Klasse
| Methode | Handlung ausgeführt |
|---|---|
| klar() | Die Methode entfernt alle Zuordnungen aus dieser TreeMap und löscht die Karte. |
| Klon() | Die Methode gibt eine flache Kopie dieser TreeMap zurück. |
| enthältKey(Objektschlüssel) | Gibt „true“ zurück, wenn diese Zuordnung eine Zuordnung für den angegebenen Schlüssel enthält. |
| enthältWert(Objektwert) | Gibt „true“ zurück, wenn diese Zuordnung einen oder mehrere Schlüssel dem angegebenen Wert zuordnet. |
| EintragSet() | Gibt eine festgelegte Ansicht der in dieser Karte enthaltenen Zuordnungen zurück. |
| firstKey() | Gibt den ersten (niedrigsten) Schlüssel zurück, der sich derzeit in dieser sortierten Karte befindet. |
| get(Objektschlüssel) | Gibt den Wert zurück, dem diese Zuordnung den angegebenen Schlüssel zuordnet. |
| headMap(Object key_value) | Die Methode gibt eine Ansicht des Teils der Karte zurück, der unbedingt kleiner als der Parameter key_value ist. |
| Schlüsselsatz() | Die Methode gibt eine Set-Ansicht der in der Treemap enthaltenen Schlüssel zurück. |
| lastKey() | Gibt den letzten (höchsten) Schlüssel zurück, der sich derzeit in dieser sortierten Karte befindet. |
| put(Objektschlüssel, Objektwert) | Die Methode wird verwendet, um eine Zuordnung in eine Karte einzufügen. |
| putAll(Map-Karte) | Kopiert alle Zuordnungen von der angegebenen Karte in diese Karte. |
| entfernen(Objektschlüssel) | Entfernt die Zuordnung für diesen Schlüssel aus dieser TreeMap, falls vorhanden. |
| Größe() | Gibt die Anzahl der Schlüsselwertzuordnungen in dieser Karte zurück. |
| subMap((K startKey, K endKey) | Die Methode gibt den Teil dieser Karte zurück, dessen Schlüssel von startKey (inklusive) bis endKey (exklusiv) reichen. |
| Werte() | Gibt eine Sammlungsansicht der in dieser Karte enthaltenen Werte zurück. |
Implementierung: Die folgenden Programme unten veranschaulichen besser, wie man die TreeMap erstellt, einfügt und durchläuft.
Illustration:
Java
// Java Program to Illustrate Operations in TreeMap> // Such as Creation, insertion> // searching, and traversal> // Importing required classes> import> java.util.*;> import> java.util.concurrent.*;> // Main class> // Implementation of TreeMap> public> class> GFG {> >// Declaring a TreeMap> >static> TreeMap tree_map;> >// Method 1> >// To create TreeMap> >static> void> create()> >{> >// Creating an empty TreeMap> >tree_map =>new> TreeMap();> >// Display message only> >System.out.println(>'TreeMap successfully'> >+>' created'>);> >}> >// Method 2> >// To Insert values in the TreeMap> >static> void> insert()> >{> >// Mapping string values to int keys> >// using put() method> >tree_map.put(>10>,>'Geeks'>);> >tree_map.put(>15>,>'4'>);> >tree_map.put(>20>,>'Geeks'>);> >tree_map.put(>25>,>'Welcomes'>);> >tree_map.put(>30>,>'You'>);> >// Display message only> >System.out.println(>'
Elements successfully'> >+>' inserted in the TreeMap'>);> >}> >// Method 3> >// To search a key in TreeMap> >static> void> search(>int> key)> >{> >// Checking for the key> >System.out.println(>'
Is key ''> + key> >+>'' present? '> >+ tree_map.containsKey(key));> >}> >// Method 4> >// To search a value in TreeMap> >static> void> search(String value)> >{> >// Checking for the value> >System.out.println(>'
Is value ''> + value> >+>'' present? '> >+ tree_map.containsValue(value));> >}> >// Method 5> >// To display the elements in TreeMap> >static> void> display()> >{> >// Displaying the TreeMap> >System.out.println(>'
Displaying the TreeMap:'>);> >System.out.println(>'TreeMap: '> + tree_map);> >}> >// Method 6> >// To traverse TreeMap> >static> void> traverse()> >{> >// Display message only> >System.out.println(>'
Traversing the TreeMap:'>);> >for> (Map.Entry e :> >tree_map.entrySet())> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> >// Method 6> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Calling above defined methods inside main()> >// Creating a TreeMap> >create();> >// Inserting the values in the TreeMap> >insert();> >// Search key '50' in the TreeMap> >search(>50>);> >// Search value 'Geeks' in the TreeMap> >search(>'Geeks'>);> >// Display the elements in TreeMap> >display();> >// Traversing the TreeMap> >traverse();> >}> }> |
>
>Ausgabe
TreeMap successfully created Elements successfully inserted in the TreeMap Is key '50' present? false Is value 'Geeks' present? true Displaying the TreeMap: TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You} Traversing the TreeMap: 10 Geeks 15 4 20 Geeks 25 Welcomes 30 You> Durchführen verschiedener Vorgänge in TreeMap
Nach der Einführung von Generics in Java 1.5 ist es möglich, den Objekttyp, der in der TreeMap gespeichert werden kann, einzuschränken. Sehen wir uns nun an, wie man einige häufig verwendete Vorgänge auf der TreeMap durchführt.
Vorgang 1: Elemente hinzufügen
Um der TreeMap ein Element hinzuzufügen, können wir die Methode put() verwenden. Die Einfügungsreihenfolge wird jedoch in der TreeMap nicht beibehalten. Intern werden für jedes Element die Schlüssel verglichen und in aufsteigender Reihenfolge sortiert.
Beispiel
Java
// Java Program to Illustrate Addition of Elements> // in TreeMap using put() Method> // Importing required classes> import> java.util.*;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Default Initialization of a TreeMap> >TreeMap tm1 =>new> TreeMap();> >// Inserting the elements in TreeMap> >// using put() method> >tm1.put(>3>,>'Geeks'>);> >tm1.put(>2>,>'For'>);> >tm1.put(>1>,>'Geeks'>);> >// Initialization of a TreeMap using Generics> >TreeMap tm2> >=>new> TreeMap();> >// Inserting the elements in TreeMap> >// again using put() method> >tm2.put(>new> Integer(>3>),>'Geeks'>);> >tm2.put(>new> Integer(>2>),>'For'>);> >tm2.put(>new> Integer(>1>),>'Geeks'>);> >// Printing the elements of both TreeMaps> >// Map 1> >System.out.println(tm1);> >// Map 2> >System.out.println(tm2);> >}> }> |
>
>Ausgabe
{1=Geeks, 2=For, 3=Geeks} {1=Geeks, 2=For, 3=Geeks}> Vorgang 2: Elemente ändern
Wenn wir nach dem Hinzufügen der Elemente das Element ändern möchten, können wir dies tun, indem wir das Element erneut mit der Methode put() hinzufügen. Da die Elemente in der Baumkarte mithilfe der Schlüssel indiziert werden, kann der Wert des Schlüssels geändert werden, indem einfach der aktualisierte Wert für den Schlüssel eingefügt wird, den wir ändern möchten.
Beispiel
Java
// Java program to Illustrate Updation of Elements> // in TreeMap using put() Method> // Importing required classes> import> java.util.*;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Initialization of a TreeMap> >// using Generics> >TreeMap tm> >=>new> TreeMap();> >// Inserting the elements in Map> >// using put() method> >tm.put(>3>,>'Geeks'>);> >tm.put(>2>,>'Geeks'>);> >tm.put(>1>,>'Geeks'>);> >// Print all current elements in map> >System.out.println(tm);> >// Inserting the element at specified> >// corresponding to specified key> >tm.put(>2>,>'For'>);> >// Printing the updated elements of Map> >System.out.println(tm);> >}> }> |
>
>Ausgabe
{1=Geeks, 2=Geeks, 3=Geeks} {1=Geeks, 2=For, 3=Geeks}> Vorgang 3: Element entfernen
Um ein Element aus der TreeMap zu entfernen, können wir die Methode „remove()“ verwenden. Diese Methode nimmt den Schlüsselwert und entfernt die Zuordnung für den Schlüssel aus dieser Baumstruktur, sofern er in der Zuordnung vorhanden ist.
Beispiel
Java
lexikographische Ordnung
// Java program to Illustrate Removal of Elements> // in TreeMap using remove() Method> // Importing required classes> import> java.util.*;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Initialization of a TreeMap> >// using Generics> >TreeMap tm> >=>new> TreeMap();> >// Inserting the elements> >// using put() method> >tm.put(>3>,>'Geeks'>);> >tm.put(>2>,>'Geeks'>);> >tm.put(>1>,>'Geeks'>);> >tm.put(>4>,>'For'>);> >// Printing all elements of Map> >System.out.println(tm);> >// Removing the element corresponding to key> >tm.remove(>4>);> >// Printing updated TreeMap> >System.out.println(tm);> >}> }> |
>
>Ausgabe
{1=Geeks, 2=Geeks, 3=Geeks, 4=For} {1=Geeks, 2=Geeks, 3=Geeks}> Vorgang 4: Iterieren durch die TreeMap
Es gibt mehrere Möglichkeiten, die Karte zu durchlaufen. Der bekannteste Weg ist die Verwendung von a for-each-Schleife und die Schlüssel holen. Der Wert des Schlüssels wird mithilfe von ermittelt getValue()-Methode .
Beispiel
Java
// Java Program to Illustrate Iterating over TreeMap> // using> // Importing required classes> import> java.util.*;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Initialization of a TreeMap> >// using Generics> >TreeMap tm> >=>new> TreeMap();> >// Inserting the elements> >// using put() method> >tm.put(>3>,>'Geeks'>);> >tm.put(>2>,>'For'>);> >tm.put(>1>,>'Geeks'>);> >// For-each loop for traversal over Map> >// via entrySet() Method> >for> (Map.Entry mapElement : tm.entrySet()) {> >int> key = (>int>)mapElement.getKey();> >// Finding the value> >String value = (String)mapElement.getValue();> >// Printing the key and value> >System.out.println(key +>' : '> + value);> >}> >}> }> |
>
>Ausgabe
1 : Geeks 2 : For 3 : Geeks>
Vorteile von TreeMap:
- Sortierte Reihenfolge: Die TreeMap stellt eine sortierte Reihenfolge ihrer Elemente bereit, basierend auf der natürlichen Reihenfolge ihrer Schlüssel oder einem benutzerdefinierten Komparator, der an den Konstruktor übergeben wird. Dies macht es in Situationen nützlich, in denen Sie Elemente in einer bestimmten Reihenfolge abrufen müssen.
- Vorhersagbare Iterationsreihenfolge: Da die Elemente in einer TreeMap in einer sortierten Reihenfolge gespeichert werden, können Sie die Reihenfolge vorhersagen, in der sie während der Iteration zurückgegeben werden, wodurch es einfacher wird, Algorithmen zu schreiben, die die Elemente in einer bestimmten Reihenfolge verarbeiten.
- Suchleistung: TreeMap bietet eine effiziente Implementierung der Map-Schnittstelle und ermöglicht das Abrufen von Elementen in logarithmischer Zeit. Dies macht es für Suchalgorithmen nützlich, bei denen Sie Elemente schnell abrufen müssen.
- Selbstausgleich: Die TreeMap wird mithilfe eines Rot-Schwarz-Baums implementiert, einer Art selbstausgleichender binärer Suchbaum. Dies sorgt für eine effiziente Leistung beim Hinzufügen, Entfernen und Abrufen von Elementen sowie bei der Beibehaltung der sortierten Reihenfolge der Elemente.
Nachteile von TreeMap:
- Langsam beim Einfügen von Elementen: Das Einfügen von Elementen in eine TreeMap kann langsamer sein als das Einfügen von Elementen in eine reguläre Map, da die TreeMap die sortierte Reihenfolge ihrer Elemente beibehalten muss.
- Schlüsseleinschränkung: Die Schlüssel in einer TreeMap müssen die java.lang.Comparable-Schnittstelle implementieren, oder es muss ein benutzerdefinierter Komparator bereitgestellt werden. Dies kann eine Einschränkung darstellen, wenn Sie benutzerdefinierte Schlüssel verwenden müssen, die diese Schnittstelle nicht implementieren.
Nachschlagewerke:
Java-Sammlungen von Maurice Naftalin und Philip Wadler. Dieses Buch bietet einen umfassenden Überblick über das Java Collections-Framework, einschließlich der TreeMap.
Java auf den Punkt gebracht von David Flanagan. Dieses Buch bietet eine Kurzreferenz für die Kernfunktionen von Java, einschließlich der TreeMap.
Java Generics and Collections von Maurice Naftalin und Philip Wadler. Dieses Buch bietet eine umfassende Anleitung zu Generika und Sammlungen in Java, einschließlich der TreeMap.