Unterschied zwischen HashMap, LinkedHashMap und TreeMap

Was ist der Unterschied zwischen HashMap, LinkedHashMapund TreeMapin Java? Ich sehe keinen Unterschied in der Ausgabe, da alle drei keySetund haben values. Was sind Hashtables?

Map m1 = new HashMap();
m1.put("map", "HashMap");
m1.put("schildt", "java2");
m1.put("mathew", "Hyden");
m1.put("schildt", "java2s");
print(m1.keySet()); 
print(m1.values()); 

SortedMap sm = new TreeMap();
sm.put("map", "TreeMap");
sm.put("schildt", "java2");
sm.put("mathew", "Hyden");
sm.put("schildt", "java2s");
print(sm.keySet()); 
print(sm.values());

LinkedHashMap lm = new LinkedHashMap();
lm.put("map", "LinkedHashMap");
lm.put("schildt", "java2");
lm.put("mathew", "Hyden");
lm.put("schildt", "java2s");
print(lm.keySet()); 
print(lm.values());

Alle drei Klassen implementieren die MapSchnittstelle und bieten meist die gleiche Funktionalität. Der wichtigste Unterschied ist die Reihenfolge, in der die Einträge durchlaufen werden:

• HashMapgibt absolut keine Garantie für die Iterationsreihenfolge. Es kann (und wird) sich sogar vollständig ändern, wenn neue Elemente hinzugefügt werden.
• TreeMapiteriert gemäß der "natürlichen Reihenfolge" der Schlüssel gemäß ihrer compareTo()Methode (oder einer extern gelieferten Comparator). Darüber hinaus wird die SortedMapSchnittstelle implementiert , die Methoden enthält, die von dieser Sortierreihenfolge abhängen.
• LinkedHashMap wird in der Reihenfolge iteriert, in der die Einträge in die Karte eingefügt wurden

"Hashtable" ist der generische Name für Hash-basierte Karten. Im Kontext der Java-API Hashtablehandelt es sich um eine veraltete Klasse aus den Tagen von Java 1.1, bevor das Sammlungsframework existierte. Es sollte nicht mehr verwendet werden, da seine API mit veralteten Methoden überfüllt ist, die die Funktionalität duplizieren, und seine Methoden synchronisiert sind (was die Leistung beeinträchtigen kann und im Allgemeinen unbrauchbar ist). Verwenden Sie ConcurrentHashMap anstelle von Hashtable.

Ich bevorzuge visuelle Präsentation:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   Property   ║       HashMap       ║      TreeMap      ║     LinkedHashMap   ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Iteration    ║  no guarantee order ║ sorted according  ║                     ║
║   Order      ║ will remain constant║ to the natural    ║    insertion-order  ║
║              ║      over time      ║    ordering       ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║  Get/put     ║                     ║                   ║                     ║
║   remove     ║         O(1)        ║      O(log(n))    ║         O(1)        ║
║ containsKey  ║                     ║                   ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║   NavigableMap    ║                     ║
║  Interfaces  ║         Map         ║       Map         ║         Map         ║
║              ║                     ║    SortedMap      ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║                   ║                     ║
║     Null     ║       allowed       ║    only values    ║       allowed       ║
║ values/keys  ║                     ║                   ║                     ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║              ║   Fail-fast behavior of an iterator cannot be guaranteed      ║
║   Fail-fast  ║ impossible to make any hard guarantees in the presence of     ║
║   behavior   ║           unsynchronized concurrent modification              ║
╠══════════════╬═════════════════════╦═══════════════════╦═════════════════════╣
║              ║                     ║                   ║                     ║
║Implementation║      buckets        ║   Red-Black Tree  ║    double-linked    ║
║              ║                     ║                   ║       buckets       ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║      Is      ║                                                               ║
║ synchronized ║              implementation is not synchronized               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

Alle drei stellen Zuordnung von eindeutigen Schlüssel auf Werte, und damit die Umsetzung Map - Schnittstelle.

1. HashMap ist eine Map, die auf dem Hashing der Schlüssel basiert . Es unterstützt O (1) get / put-Operationen. Schlüssel müssen konsistente Implementierungen von hashCode()und haben,equals() damit dies funktioniert.

2. LinkedHashMap ist HashMap sehr ähnlich, erhöht jedoch die Bekanntheit der Reihenfolge, in der Elemente hinzugefügt werden (oder auf die zugegriffen wird), sodass die Iterationsreihenfolge der Einfügereihenfolge (oder der Zugriffsreihenfolge, abhängig von den Konstruktionsparametern) entspricht.

3. TreeMap ist eine baumbasierte Zuordnung. Die Put / Get-Operationen benötigen O (log n) Zeit. Elemente müssen über einen Vergleichsmechanismus verfügen, entweder mit Comparable oder Comparator. Die Iterationsreihenfolge wird durch diesen Mechanismus bestimmt.

Sehen Sie im folgenden Diagramm ( größere ), wo sich jede Klasse in der Klassenhierarchie befindet . TreeMap implementiert SortedMapund NavigableMapwährend HashMapnicht.

HashTableist veraltet und die entsprechende ConcurrentHashMapKlasse sollte verwendet werden.

HashMap

• Es hat Paarwerte (Schlüssel, Werte)
• KEINE Duplizierungsschlüsselwerte
• ungeordnet unsortiert
• Es erlaubt einen Nullschlüssel und mehr als einen Nullwert

Hash-tabelle

• das gleiche wie Hash-Karte
• Es sind keine Nullschlüssel und Nullwerte zulässig

LinkedHashMap

• Es ist eine geordnete Version der Kartenimplementierung
• Basierend auf verknüpften Listen- und Hashing-Datenstrukturen

Baumkarte

• Bestellte und sortierte Version
• basierend auf Hashing-Datenstrukturen

Nur noch ein paar Eingaben aus meiner eigenen Erfahrung mit Karten, wann ich jede verwenden würde:

• HashMap - Am nützlichsten, wenn Sie nach einer (schnellen) Implementierung mit der besten Leistung suchen.
• TreeMap (SortedMap-Schnittstelle) - Am nützlichsten, wenn ich die Schlüssel in einer von mir definierten Reihenfolge sortieren oder durchlaufen möchte.
• LinkedHashMap - Kombiniert die Vorteile einer garantierten Bestellung bei TreeMap ohne die erhöhten Kosten für die Wartung der TreeMap. (Es ist fast so schnell wie die HashMap). Insbesondere bietet die LinkedHashMap auch einen guten Ausgangspunkt für die Erstellung eines Cache-Objekts durch Überschreiben der removeEldestEntry()Methode. Auf diese Weise können Sie ein Cache-Objekt erstellen, das Daten anhand einiger von Ihnen definierter Kriterien ablaufen lässt.

Alle drei Klassen HashMap, TreeMapund LinkedHashMapGeräte - java.util.MapSchnittstelle und stellt Zuordnung von eindeutigen Schlüssel auf Werte.

HashMap

1. A HashMapenthält Werte basierend auf dem Schlüssel.

2. Es enthält nur eindeutige Elemente.

3. Es kann einen Nullschlüssel und mehrere Nullwerte haben.

4. Es wird keine Ordnung aufrechterhalten .

   public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

LinkedHashMap

1. A LinkedHashMapenthält Werte basierend auf dem Schlüssel.
2. Es enthält nur eindeutige Elemente.
3. Es kann einen Nullschlüssel und mehrere Nullwerte haben.

4. Es ist die gleiche wie HashMap anstelle hält Auftrag . // Siehe Klassenverzögerung unten

   public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

Baumkarte

1. A TreeMapenthält Werte basierend auf dem Schlüssel. Es implementiert die NavigableMap-Schnittstelle und erweitert die AbstractMap-Klasse.
2. Es enthält nur eindeutige Elemente.
3. Es kann keinen Nullschlüssel haben, aber mehrere Nullwerte.

4. Es ist dasselbe wie HashMapstattdessen die aufsteigende Reihenfolge beizubehalten (sortiert nach der natürlichen Reihenfolge seines Schlüssels).

   public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable

Hash-tabelle

1. Eine Hashtabelle ist ein Array von Listen. Jede Liste wird als Bucket bezeichnet. Die Position des Buckets wird durch Aufrufen der Methode hashcode () identifiziert. Eine Hashtabelle enthält Werte basierend auf dem Schlüssel.
2. Es enthält nur eindeutige Elemente.
3. Es darf keinen Nullschlüssel oder -wert haben.
4. Es ist synchronisiert .

5. Es ist eine Legacy-Klasse.

   public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable

Ref: http://javarevisited.blogspot.in/2015/08/difference-between-HashMap-vs-TreeMap-vs-LinkedHashMap-Java.html

HashMap übernimmt keinerlei Garantie für die Iterationsreihenfolge. Es kann (und wird) sich sogar vollständig ändern, wenn neue Elemente hinzugefügt werden. TreeMap iteriert gemäß der "natürlichen Reihenfolge" der Schlüssel gemäß ihrer compareTo () -Methode (oder einem extern bereitgestellten Comparator). Darüber hinaus wird die SortedMap-Schnittstelle implementiert, die Methoden enthält, die von dieser Sortierreihenfolge abhängen. LinkedHashMap iteriert in der Reihenfolge, in der die Einträge in die Karte eingefügt wurden

Schauen Sie sich an, wie unterschiedlich die Leistung ist.

Baumkarte, die eine Implementierung der sortierten Karte ist. Die Komplexität der Operation put, get und includesKey ist aufgrund der natürlichen Reihenfolge O (log n)

@Amit: SortedMapist eine Schnittstelle, während TreeMapes sich um eine Klasse handelt, die die SortedMapSchnittstelle implementiert . Das heißt, wenn das Protokoll befolgt wird, zu dem die SortedMapImplementierer aufgefordert werden. Ein Baum kann, sofern er nicht als Suchbaum implementiert ist, keine geordneten Daten liefern, da der Baum jede Art von Baum sein kann. Damit TreeMap wie eine sortierte Reihenfolge funktioniert, wird SortedMap implementiert (z. B. Binary Search Tree - BST, Balanced BST wie AVL und RB Tree, sogar Ternary Search Tree - meistens für iterative Suchen in geordneter Weise).

public class TreeMap<K,V>
extends AbstractMap<K,V>
implements SortedMap<K,V>, Cloneable, Serializable

In NUT-SHELL HashMap: Gibt Daten in O (1) an, keine Reihenfolge

TreeMap : gibt Daten in O (log N), Basis 2. mit geordneten Schlüsseln an

LinkedHashMap: ist eine Hash-Tabelle mit verknüpfter Liste (denken Sie an indexed-SkipList), mit der Daten so gespeichert werden können, wie sie in den Baum eingefügt werden. Am besten geeignet für die Implementierung von LRU (zuletzt verwendet).

Im Folgenden sind die Hauptunterschiede zwischen HashMap und TreeMap aufgeführt

1. HashMap verwaltet keine Reihenfolge. Mit anderen Worten, HashMap bietet keine Garantie dafür, dass das zuerst eingefügte Element zuerst gedruckt wird. Wie bei TreeSet werden auch TreeMap-Elemente nach der natürlichen Reihenfolge ihrer Elemente sortiert

2. Interne HashMap-Implementierung verwendet Hashing und TreeMap verwendet intern die Rot-Schwarz-Baumimplementierung.

3. HashMap kann einen Nullschlüssel und viele Nullwerte speichern. TreeMap kann keine Nullschlüssel enthalten, kann jedoch viele Nullwerte enthalten.

4. HashMap benötigt eine konstante Zeitleistung für die grundlegenden Operationen wie get und put, dh O (1). Gemäß Oracle-Dokumenten bietet TreeMap garantierte log (n) Zeitkosten für die get- und put-Methode.

5. HashMap ist viel schneller als TreeMap, da die Leistungszeit von HashMap für die meisten Vorgänge gegenüber der Protokollzeit TreeMap konstant ist.

6. HashMap verwendet im Vergleich die Methode equals (), während TreeMap die Methode compareTo () verwendet, um die Reihenfolge aufrechtzuerhalten.

7. HashMap implementiert die Map-Schnittstelle, während TreeMap die NavigableMap-Schnittstelle implementiert.

Dies sind verschiedene Implementierungen derselben Schnittstelle. Jede Implementierung hat einige Vor- und Nachteile (schnelles Einfügen, langsame Suche) oder umgekehrt.

Weitere Informationen finden Sie im Javadoc von TreeMap , HashMap , LinkedHashMap .

Die Hash-Map behält die Einfügereihenfolge nicht bei.
Beispiel. Hashmap Wenn Sie Schlüssel als einfügen

1  3
5  9
4   6
7   15
3   10

Es kann es speichern als

4  6
5  9
3  10
1  3
7  15

Die verknüpfte Hashmap behält die Einfügereihenfolge bei.

Beispiel.
Wenn Sie Schlüssel einfügen

1  3
5  9
4   6
7   15
3   10

Es wird gespeichert als

1  3
5  9
4   6
7   15
3   10

das gleiche wie wir einfügen.

In der Baumkarte werden die Werte in aufsteigender Reihenfolge der Schlüssel gespeichert. Beispiel.
Wenn Sie Schlüssel einfügen

1  3
5  9
4   6
7   15
3   10

Es wird gespeichert als

1  3
3  10
4   6
5   9
7   15

• HashMap:

  • Bestellung nicht aufrechterhalten
  • Schneller als LinkedHashMap
  • Wird zum Speichern von Objekthaufen verwendet

• LinkedHashMap:

  • Die Einfügereihenfolge von LinkedHashMap wird beibehalten
  • Langsamer als HashMap und schneller als TreeMap
  • Wenn Sie eine Einfügereihenfolge beibehalten möchten, verwenden Sie diese.

• Baumkarte:

  • TreeMap ist eine baumbasierte Zuordnung
  • TreeMap folgt der natürlichen Reihenfolge der Schlüssel
  • Langsamer als HashMap und LinkedHashMap
  • Verwenden Sie TreeMap, wenn Sie die natürliche (Standard-) Reihenfolge beibehalten müssen

Alle bieten eine Schlüssel-> Wertekarte und eine Möglichkeit, die Schlüssel zu durchlaufen. Der wichtigste Unterschied zwischen diesen Klassen sind die Zeitgarantien und die Reihenfolge der Schlüssel.

1. HashMap bietet 0 (1) Nachschlagen und Einfügen. Wenn Sie jedoch die Schlüssel durchlaufen, ist die Reihenfolge der Schlüssel im Wesentlichen willkürlich. Es wird durch eine Reihe von verknüpften Listen implementiert.
2. TreeMap bietet die Suche und Einfügung von O (log N). Die Schlüssel werden bestellt. Wenn Sie also die Schlüssel in sortierter Reihenfolge durchlaufen müssen, können Sie dies tun. Dies bedeutet, dass Schlüssel die vergleichbare Schnittstelle implementieren müssen. TreeMap wird von einem Rot-Schwarz-Baum implementiert.
3. LinkedHashMap bietet 0 (1) Nachschlagen und Einfügen. Die Schlüssel werden nach ihrer Einfügereihenfolge sortiert. Es wird durch doppelt verknüpfte Buckets implementiert.

Stellen Sie sich vor, Sie haben eine leere TreeMap, HashMap und LinkedHashMap an die folgende Funktion übergeben:

void insertAndPrint(AbstractMap<Integer, String> map) {
  int[] array= {1, -1, 0};
  for (int x : array) {
    map.put(x, Integer.toString(x));
  }
  for (int k: map.keySet()) {
   System.out.print(k + ", ");
  }
}

Die Ausgabe für jedes sieht wie folgt aus.

Für HashMap war die Ausgabe in meinen eigenen Tests {0, 1, -1}, aber es kann sich um eine beliebige Reihenfolge handeln. Es gibt keine Garantie für die Bestellung.
Treemap, die Ausgabe war {-1, 0, 1}
LinkedList, die Ausgabe war {1, -1, 0}

Obwohl es hier viele hervorragende Antworten gibt, möchte ich meine eigene Tabelle präsentieren, in der die verschiedenen Mapmit Java 11 gebündelten Implementierungen beschrieben werden .

Wir können diese Unterschiede in der Tabellengrafik sehen:

• HashMapist der allgemeine Zweck, der Map häufig verwendet wird, wenn Sie keine besonderen Bedürfnisse haben.
• LinkedHashMaperweitert HashMapund fügt dieses Verhalten hinzu: Verwaltet eine Reihenfolge, die Reihenfolge, in der die Einträge ursprünglich hinzugefügt wurden . Durch Ändern des Werts für die Schlüsselwerteingabe wird der Platz in der Bestellung nicht geändert.
• TreeMapAuch behält eine Reihenfolge bei, verwendet jedoch entweder (a) die "natürliche" Reihenfolge , dh den Wert der compareToMethode für die auf der ComparableSchnittstelle definierten Schlüsselobjekte , oder (b) ruft eine vonComparator Ihnen bereitgestellte Implementierung auf .
  • TreeMapimplementiert sowohl die SortedMapSchnittstelle als auch deren Nachfolger, die NavigableMapSchnittstelle.
• NULL s: TreeMapErlaubt kein NULL als Schlüssel , während HashMap& LinkedHashMapdo.
  • Alle drei erlauben NULL als Wert.
• HashTableist Vermächtnis von Java 1 . Unterstützt von der ConcurrentHashMapKlasse. Zitieren des Javadoc: ConcurrentHashMapfolgt der gleichen Funktionsspezifikation wie Hashtableund enthält Versionen von Methoden, die jeder Methode von entsprechen Hashtable.

HashMap
kann einen Nullschlüssel enthalten.

HashMap behält keine Reihenfolge bei.

Baumkarte

TreeMap darf keinen Nullschlüssel enthalten.

TreeMap behält die aufsteigende Reihenfolge bei.

LinkedHashMap

LinkedHashMap kann verwendet werden, um die Einfügereihenfolge zu verwalten, in der Schlüssel in Map eingefügt werden, oder es kann auch verwendet werden, um eine Zugriffsreihenfolge zu verwalten, in der auf Schlüssel zugegriffen wird.

Beispiele ::

1) HashMap map = new HashMap ();

    map.put(null, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");`enter code here`
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    } 

2) TreeMap map = new TreeMap ();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

3) LinkedHashMap map = new LinkedHashMap ();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

Das wichtigste unter allen dreien ist, wie sie die Reihenfolge der Einträge speichern.

HashMap- Speichert nicht die Reihenfolge der Einträge. z.B.

public static void main(String[] args){
        HashMap<String,Integer> hashMap = new HashMap<>();
        hashMap.put("First",1);// First ---> 1 is put first in the map
        hashMap.put("Second",2);//Second ---> 2 is put second in the map
        hashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : hashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

LinkedHashMap: Es speichert die Reihenfolge, in der Eingaben gemacht wurden. z.B:

public static void main(String[] args){
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("First",1);// First ---> 1 is put first in the map
        linkedHashMap.put("Second",2);//Second ---> 2 is put second in the map
        linkedHashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : linkedHashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

TreeMap: Es speichert die Einträge in aufsteigender Reihenfolge der Schlüssel. z.B:

public static void main(String[] args) throws IOException {
        TreeMap<String,Integer> treeMap = new TreeMap<>();
        treeMap.put("A",1);// A---> 1 is put first in the map
        treeMap.put("C",2);//C---> 2 is put second in the map
        treeMap.put("B",3); //B--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : treeMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }