Unterschiede zwischen HashMap und Hashtable?

Question

Was sind die Unterschiede zwischen a HashMap und ein Hashtable in Java?

Was ist für Nicht-Thread-Anwendungen effizienter?

Answer 1

Es gibt mehrere Unterschiede zwischen HashMap Und Hashtable in Java:

1. Hashtable Ist synchronisiert, wohingegen HashMap ist nicht.Das macht HashMap besser für Anwendungen ohne Thread, da nicht synchronisierte Objekte normalerweise eine bessere Leistung erbringen als synchronisierte.

2. Hashtable erlaubt nicht null Schlüssel oder Werte. HashMap erlaubt einen null Schlüssel und beliebig viele null Werte.

3. Eine der Unterklassen von HashMap ist LinkedHashMap, also für den Fall, dass Sie eine vorhersehbare Iterationsreihenfolge wünschen (die standardmäßig die Einfügereihenfolge ist), können Sie diese einfach austauschen HashMap Für ein LinkedHashMap.Dies wäre nicht so einfach, wenn Sie es verwenden würden Hashtable.

Da die Synchronisierung für Sie kein Problem darstellt, würde ich es empfehlen HashMap.Wenn die Synchronisierung zu einem Problem wird, können Sie auch einen Blick darauf werfen ConcurrentHashMap.

Answer 2

Beachten Sie, dass in vielen Antworten angegeben wird, dass Hashtable synchronisiert ist. In der Praxis bringt Ihnen das sehr wenig ein. Die Synchronisierung erfolgt über die Accessor-/Mutator-Methoden und verhindert, dass zwei Threads gleichzeitig zur Karte hinzugefügt oder daraus entfernt werden. In der realen Welt benötigen Sie jedoch häufig eine zusätzliche Synchronisierung.

Eine sehr verbreitete Redewendung ist „check then put“ – d. h.Suchen Sie nach einem Eintrag in der Map, und fügen Sie es hinzu, falls es noch nicht vorhanden ist.Dies ist in keiner Weise eine atomare Operation, unabhängig davon, ob Sie sie verwenden Hashtable oder HashMap.

Eine gleichwertige synchronisierte HashMap kann bezogen werden durch:

Collections.synchronizedMap(myMap);

Aber um diese Logik richtig umzusetzen, brauchen Sie zusätzliche Synchronisation der Form:

synchronized(myMap) {
    if (!myMap.containsKey("tomato"))
        myMap.put("tomato", "red");
}

Sogar die Iteration über a Hashtable's Einträge (oder a HashMap erhalten von Collections.synchronizedMap) ist nicht threadsicher, es sei denn, Sie schützen auch die Map durch zusätzliche Synchronisation nicht verändert werden.

Implementierungen der ConcurrentMap Schnittstelle (z.B ConcurrentHashMap) lösen Sie einiges davon, indem Sie Folgendes einschließen Thread-sichere Check-then-Act-Semantik wie zum Beispiel:

ConcurrentMap.putIfAbsent(key, value);

Answer 3

Hashtable gilt als Legacy-Code.Es gibt nichts darüber Hashtable das geht nicht mit HashMap oder Ableitungen davon HashMap, Daher sehe ich bei neuem Code keine Rechtfertigung für eine Rückkehr Hashtable.

Answer 4

Diese Frage wird häufig in Vorstellungsgesprächen gestellt, um zu überprüfen, ob der Kandidat die korrekte Verwendung von Sammlungsklassen versteht und sich der verfügbaren alternativen Lösungen bewusst ist.

1. Die Klasse HashMap entspricht in etwa der Klasse Hashtable, außer dass sie nicht synchronisiert ist und Nullen zulässt.(HashMap erlaubt Nullwerte als Schlüssel und Wert, während Hashtable keine Nullwerte zulässt).
2. HashMap garantiert nicht, dass die Reihenfolge der Karte über die Zeit konstant bleibt.
3. HashMap ist nicht synchronisiert, während Hashtable synchronisiert ist.
4. Der Iterator in der HashMap ist ausfallsicher, während der Enumerator für die Hashtable dies nicht ist, und löst eine ConcurrentModificationException aus, wenn ein anderer Thread die Map strukturell ändert, indem er ein Element außer der eigenen Methode „remove()“ des Iterators hinzufügt oder entfernt.Dies ist jedoch kein garantiertes Verhalten und wird von JVM nach besten Kräften durchgeführt.

Hinweis zu einigen wichtigen Begriffen

1. Synchronisiert bedeutet, dass jeweils nur ein Thread eine Hash-Tabelle ändern kann.Im Grunde bedeutet dies, dass jeder Thread vor der Aktualisierung einer Hashtabelle eine Sperre für das Objekt erwerben muss, während andere darauf warten, dass die Sperre freigegeben wird.
2. Ausfallsicherheit ist im Kontext von Iteratoren relevant.Wenn ein Iterator für ein Sammlungsobjekt erstellt wurde und ein anderer Thread versucht, das Sammlungsobjekt „strukturell“ zu ändern, wird eine gleichzeitige Änderungsausnahme ausgelöst.Es ist jedoch für andere Threads möglich, die Methode „set“ aufzurufen, da sie die Sammlung nicht „strukturell“ ändert.Wenn die Sammlung jedoch vor dem Aufruf von „set“ strukturell geändert wurde, wird „IllegalArgumentException“ ausgelöst.
3. Strukturelle Änderungen bedeuten das Löschen oder Einfügen von Elementen, die die Struktur der Karte effektiv verändern könnten.

HashMap kann synchronisiert werden

Map m = Collections.synchronizeMap(hashMap);

Map bietet Sammlungsansichten anstelle der direkten Unterstützung für Iterationen über Enumeration-Objekte.Sammlungsansichten verbessern die Ausdruckskraft der Schnittstelle, wie weiter unten in diesem Abschnitt erläutert.Mit Map können Sie Schlüssel, Werte oder Schlüssel-Wert-Paare durchlaufen.Hashtable bietet die dritte Option nicht.Karte bietet einen sicheren Weg , um Einträge während der Iteration zu entfernen;Hashtable nicht.Schließlich behebt Map einen kleinen Mangel in der Hashtable-Schnittstelle.Hashtable verfügt über eine Methode namens contains, die true zurückgibt, wenn die Hashtable enthält einen bestimmten Wert.Angesichts des Namens würde man dies erwarten -Methode, um true zurückzugeben, wenn die Hashtable einen bestimmten Schlüssel enthielt, da Der Schlüssel ist der primäre Zugriffsmechanismus für eine Hashtable.Die Karte Interface beseitigt diese Quelle der Verwirrung, indem die Methode umbenannt wird containsValue.Außerdem wird dadurch die Konsistenz der Schnittstelle verbessert. containsValue entspricht containsKey.

Die Kartenschnittstelle

Answer 5

HashMap:Eine Implementierung der Map Schnittstelle, die Hash-Codes verwendet, um ein Array zu indizieren.Hashtable:Hallo, 1998 hat angerufen.Sie wollen ihre Sammlungs-API zurück.

Aber im Ernst, Sie sollten lieber die Finger davon lassen Hashtable insgesamt.Für Single-Thread-Apps benötigen Sie keinen zusätzlichen Synchronisierungsaufwand.Bei Anwendungen mit hoher Parallelität kann die paranoide Synchronisierung zu Ausfällen, Deadlocks oder unnötigen Pausen bei der Garbage Collection führen.Wie Tim Howland betont hat, könnten Sie Folgendes verwenden ConcurrentHashMap stattdessen.

Answer 6

Denk daran, dass HashTable war eine Legacy-Klasse vor der Einführung des Java Collections Framework (JCF) und wurde später zur Implementierung des nachgerüstet Map Schnittstelle.So war Vector Und Stack.

Halten Sie sich daher in neuem Code immer von ihnen fern, da es im JCF immer eine bessere Alternative gibt wie andere darauf hingewiesen hatten.

Hier ist das Spickzettel für die Java-Sammlung die Sie nützlich finden werden.Beachten Sie, dass der graue Block die Legacy-Klassen HashTable, Vector und Stack enthält.

Answer 7

Zusätzlich zu dem, was izb gesagt hat, HashMap erlaubt Nullwerte, während die Hashtable nicht.

Beachten Sie das auch Hashtable erweitert die Dictionary Klasse, die als die Javadocs Zustand, ist veraltet und wurde durch die ersetzt Map Schnittstelle.

Answer 8

Es gibt bereits viele gute Antworten.Ich füge einige neue Punkte hinzu und fasse es zusammen.

HashMap Und Hashtable beide dienen der Lagerung Daten in Schlüssel- und Wertform.Beide verwenden eine Hashing-Technik, um eindeutige Schlüssel zu speichern.Es gibt jedoch viele Unterschiede zwischen den HashMap- und Hashtable-Klassen, die unten aufgeführt sind.

HashMap

1. HashMap ist nicht synchronisiert.Es ist nicht threadsicher und kann ohne ordnungsgemäßen Synchronisierungscode nicht von mehreren Threads gemeinsam genutzt werden.
2. HashMap erlaubt einen Nullschlüssel und mehrere Nullwerte.
3. HashMap ist eine neue Klasse, die in JDK 1.2 eingeführt wurde.
4. HashMap ist schnell.
5. Wir können das machen HashMap wie durch Aufruf dieses Codes synchronisiert
   Map m = Collections.synchronizedMap(HashMap);
6. HashMap wird von Iterator durchlaufen.
7. Iterator in HashMap ist ausfallsicher.
8. HashMap erbt die AbstractMap-Klasse.

Hash-tabelle

1. Hashtable synchronisiert ist.Es ist Thread-sicher und kann mit vielen Threads geteilt werden.
2. Hashtable erlaubt keinen Nullschlüssel oder -wert.
3. Hashtable ist eine Legacy-Klasse.
4. Hashtable ist langsam.
5. Hashtable ist intern synchronisiert und kann nicht desynchronisiert werden.
6. Hashtable wird von Enumerator und Iterator durchlaufen.
7. Enumerator in Hashtable ist nicht ausfallsicher.
8. Hashtable erbt die Dictionary-Klasse.

Weiterführende Literatur Was ist der Unterschied zwischen HashMap und Hashtable in Java?

Answer 9

Schauen Sie sich dieses Diagramm an.Es bietet Vergleiche zwischen verschiedenen Datenstrukturen zusammen mit HashMap und Hashtable.Der Vergleich ist präzise, ​​klar und leicht verständlich.

Java-Sammlungsmatrix

Answer 10

Hashtable ähnelt dem HashMap und hat eine ähnliche Schnittstelle.Es wird empfohlen, dass Sie es verwenden HashMap, es sei denn, Sie benötigen Unterstützung für ältere Anwendungen oder Sie benötigen eine Synchronisierung, wie z Hashtables Methoden werden synchronisiert.In Ihrem Fall, da Sie kein Multithreading betreiben, HashMaps sind Ihre beste Wahl.

Answer 11

Ein weiterer wesentlicher Unterschied zwischen Hashtable und Hashmap besteht darin, dass der Iterator in der HashMap ausfallsicher ist, während der Enumerator für die Hashtable dies nicht ist, und eine ConcurrentModificationException auslöst, wenn ein anderer Thread die Map strukturell ändert, indem er ein Element außer der eigenen Methode „remove()“ des Iterators hinzufügt oder entfernt.Dies ist jedoch kein garantiertes Verhalten und wird von JVM nach besten Kräften durchgeführt.“

Meine Quelle: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html

Answer 12

Neben all den anderen wichtigen Aspekten, die hier bereits erwähnt wurden, bietet die Collections API (z. B.Kartenschnittstelle) wird ständig geändert, um den „neuesten und besten“ Ergänzungen der Java-Spezifikation zu entsprechen.

Vergleichen Sie beispielsweise die Java 5 Map-Iteration:

for (Elem elem : map.keys()) {
  elem.doSth();
}

im Vergleich zum alten Hashtable-Ansatz:

for (Enumeration en = htable.keys(); en.hasMoreElements(); ) {
  Elem elem = (Elem) en.nextElement();
  elem.doSth();
}

In Java 1.8 wird uns außerdem versprochen, HashMaps wie in guten alten Skriptsprachen erstellen und darauf zugreifen zu können:

Map<String,Integer> map = { "orange" : 12, "apples" : 15 };
map["apples"];

Aktualisieren: Nein, sie werden nicht in 1,8 landen...:(

Werden die Sammlungserweiterungen von Project Coin in JDK8 enthalten sein?

Answer 13

• Hash-tabelle synchronisiert ist, können Sie es verwenden, wenn Sie es in einem einzelnen Thread verwenden HashMap, bei der es sich um eine nicht synchronisierte Version handelt.Nicht synchronisierte Objekte sind oft etwas leistungsfähiger.Wenn übrigens mehrere Threads gleichzeitig auf eine HashMap zugreifen und mindestens einer der Threads die Map strukturell verändert, muss diese extern synchronisiert werden.Sie können eine nicht synchronisierte Karte in eine synchronisierte einschließen, indem Sie Folgendes verwenden:

  Map m = Collections.synchronizedMap(new HashMap(...));
  

• HashTable kann nur Nicht-Null-Objekte als Schlüssel oder als Wert enthalten.HashMap kann einen Nullschlüssel und Nullwerte enthalten.

• Die von Map zurückgegebenen Iteratoren sind ausfallsicher. Wenn die Map zu irgendeinem Zeitpunkt nach der Erstellung des Iterators strukturell geändert wird, außer durch die eigene Remove-Methode des Iterators, wirft der Iterator ein ConcurrentModificationException.Somit fällt der Iterator angesichts gleichzeitiger Änderungen schnell und sauber aus, anstatt willkürliches, nicht deterministisches Verhalten zu einem unbestimmten Zeitpunkt in der Zukunft zu riskieren. Wohingegen Die von den Schlüssel- und Elementmethoden von Hashtable zurückgegebenen Aufzählungen sind nicht ausfallsicher.

• HashTable und HashMap sind Mitglieder von Java Collections Framework (Seit der Java 2-Plattform v1.2 wurde HashTable nachgerüstet, um die Map-Schnittstelle zu implementieren.)

• HashTable gilt als Legacy-Code, dessen Verwendung in der Dokumentation empfohlen wird ConcurrentHashMap anstelle von Hashtable, wenn eine threadsichere, hochgradig gleichzeitige Implementierung gewünscht wird.

• HashMap garantiert nicht die Reihenfolge, in der Elemente zurückgegeben werden.Für HashTable ist es vermutlich dasselbe, aber ich bin mir nicht ganz sicher. Ich finde keine Ressource, die das eindeutig angibt.

Answer 14

HashMap Und Hashtable weisen ebenfalls erhebliche algorithmische Unterschiede auf.Das hat noch niemand erwähnt, deshalb erwähne ich es. HashMap erstellt eine Hash-Tabelle mit einer Potenz von zwei Größen, erhöht sie dynamisch, sodass sich in jedem Bucket höchstens etwa acht Elemente (Kollisionen) befinden, und rührt die Elemente sehr gut für allgemeine Elementtypen um.Allerdings ist die Hashtable Die Implementierung bietet eine bessere und feinere Kontrolle über das Hashing, wenn Sie wissen, was Sie tun. Sie können nämlich die Tabellengröße festlegen, indem Sie z. B.die Primzahl, die der Domänengröße Ihrer Werte am nächsten kommt, und dies führt zu einer besseren Leistung als HashMap, d. h.in einigen Fällen weniger Kollisionen.

Abgesehen von den offensichtlichen Unterschieden, die in dieser Frage ausführlich besprochen werden, betrachte ich den Hashtable als ein Auto mit „manuellem Antrieb“, bei dem Sie eine bessere Kontrolle über das Hashing haben, und die HashMap als das Gegenstück zum „automatischen Antrieb“, das im Allgemeinen eine gute Leistung erbringt.

Answer 15

Hashtable ist synchronisiert, HashMap hingegen nicht.Das macht Hashtable langsamer als Hashmap.

Verwenden Sie für Apps ohne Threads HashMap, da sie ansonsten hinsichtlich der Funktionalität gleich sind.

Answer 16

Basierend auf den Informationen Hier, würde ich die Verwendung von HashMap empfehlen.Ich denke, der größte Vorteil besteht darin, dass Java Sie daran hindert, es zu ändern, während Sie darüber iterieren, es sei denn, Sie tun dies über den Iterator.

Answer 17

A Collection – manchmal auch Container genannt – ist einfach ein Objekt, das mehrere Elemente zu einer einzigen Einheit zusammenfasst. Collections werden zum Speichern, Abrufen, Bearbeiten und Kommunizieren aggregierter Daten verwendet.Ein Sammlungsrahmen ^W ist eine einheitliche Architektur zur Darstellung und Bearbeitung von Sammlungen.

Der HashMap JDK1.2 und Hashtable ^JDK1.0, beide werden verwendet, um eine Gruppe von Objekten darzustellen, die in dargestellt werden <Key, Value> Paar.Jede <Key, Value> Paar heißt Entry Objekt.Auf die Sammlung von Einträgen wird durch das Objekt verwiesen HashMap Und Hashtable.Schlüssel in einer Sammlung müssen einzigartig oder unverwechselbar sein.[da sie verwendet werden, um einen zugeordneten Wert eines bestimmten Schlüssels abzurufen.Werte in einer Sammlung können dupliziert werden.]

---

« Superklassen-, Legacy- und Collection-Framework-Mitglied

Hashtable ist eine Legacy-Klasse, die eingeführt wurde JDK1.0, eine Unterklasse der Dictionary-Klasse.Aus JDK1.2 Hashtable wurde überarbeitet, um das zu implementieren Kartenschnittstelle um ein Mitglied des Sammlungs-Frameworks zu machen.HashMap ist seit Beginn seiner Einführung Mitglied des Java Collection Framework JDK1.2.HashMap ist die Unterklasse der AbstractMap-Klasse.

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

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

« Anfangskapazität und Auslastungsfaktor

Die Kapazität ist die Anzahl der Buckets in der Hash-Tabelle, und die anfängliche Kapazität ist einfach die Kapazität zum Zeitpunkt der Erstellung der Hash-Tabelle.Beachten Sie, dass die Hash-Tabelle geöffnet ist:im Falle eines „hashcollision", speichert ein einzelner Bucket mehrere Einträge, die nacheinander durchsucht werden müssen.Der Auslastungsfaktor ist ein Maß dafür, wie voll die Hash-Tabelle werden darf, bevor ihre Kapazität automatisch erhöht wird.

HashMap erstellt eine leere Hash-Tabelle mit der standardmäßigen Anfangskapazität (16) und der Standardlastfaktor (0,75).Wobei Hashtable eine leere Hashtabelle mit einer standardmäßigen Anfangskapazität erstellt (11) und Lastfaktor/Füllverhältnis (0,75).

« Strukturelle Änderung im Falle einer Hash-Kollision

HashMap, Hashtable Im Falle von Hash-Kollisionen speichern sie die Karteneinträge in verknüpften Listen. Von Java8 für HashMap Wenn der Hash-Bucket einen bestimmten Schwellenwert überschreitet, wechselt dieser Bucket von linked list of entries to a balanced tree.die die Worst-Case-Leistung von O(n) auf O(log n) verbessern.Beim Konvertieren der Liste in einen Binärbaum wird der Hashcode als Verzweigungsvariable verwendet.Wenn sich im selben Bucket zwei verschiedene Hashcodes befinden, gilt einer als größer und befindet sich rechts vom Baum und der andere links.Aber wenn beide Hashcodes gleich sind, HashMap geht davon aus, dass die Schlüssel vergleichbar sind, und vergleicht den Schlüssel, um die Richtung zu bestimmen, sodass eine gewisse Reihenfolge beibehalten werden kann.Es ist eine gute Praxis, die Schlüssel herzustellen HashMap vergleichbar.Beim Hinzufügen von Einträgen, wenn die Bucket-Größe erreicht ist TREEIFY_THRESHOLD = 8 Konvertieren Sie eine verknüpfte Liste von Einträgen in einen ausgeglichenen Baum, indem Sie Einträge entfernen, die kleiner sind als TREEIFY_THRESHOLD und höchstens UNTREEIFY_THRESHOLD = 6 wandelt den ausgeglichenen Baum wieder in eine verknüpfte Liste von Einträgen um. ^{Java 8 SRC, Stapelpfosten}

« Sammlungsansicht-Iteration, Fail-Fast und Fail-Safe

    +--------------------+-----------+-------------+
    |                    | Iterator  | Enumeration |
    +--------------------+-----------+-------------+
    | Hashtable          | fail-fast |    safe     |
    +--------------------+-----------+-------------+
    | HashMap            | fail-fast | fail-fast   |
    +--------------------+-----------+-------------+
    | ConcurrentHashMap  |   safe    |   safe      |
    +--------------------+-----------+-------------+

Iterator ist von Natur aus ausfallsicher.Das heißt, es löst eine ConcurrentModificationException aus, wenn eine Sammlung während der Iteration mit einer anderen Methode als der eigenen Methode „remove()“ geändert wird.Wohingegen Enumeration ist von Natur aus ausfallsicher.Es werden keine Ausnahmen ausgelöst, wenn eine Sammlung während der Iteration geändert wird.

Laut Java API Docs wird Iterator immer der Enumeration vorgezogen.

_{NOTIZ: Die Funktionalität der Enumeration-Schnittstelle wird durch die Iterator-Schnittstelle dupliziert.Darüber hinaus fügt Iterator eine optionale Entfernungsoperation hinzu und verfügt über kürzere Methodennamen.Bei neuen Implementierungen sollte die Verwendung von Iterator anstelle von Enumeration in Betracht gezogen werden.}

In Mit Java 5 wurde die ConcurrentMap-Schnittstelle eingeführt: ConcurrentHashMap - eine hochgradig gleichzeitige, leistungsstarke ConcurrentMap Implementierung, die durch eine Hash-Tabelle unterstützt wird.Diese Implementierung blockiert niemals beim Durchführen von Abrufen und ermöglicht es dem Client, die Parallelitätsebene für Aktualisierungen auszuwählen.Es ist als Ersatz für gedacht Hashtable:zusätzlich zur Umsetzung ConcurrentMap, unterstützt es alle „Legacy“-Methoden, die für Hashtable.

• Jede HashMapEntrys Wert ist flüchtig Dadurch wird eine feinkörnige Konsistenz für umstrittene Änderungen und nachfolgende Lesevorgänge gewährleistet.Jeder Lesevorgang spiegelt das zuletzt abgeschlossene Update wider

• Iteratoren und Aufzählungen sind ausfallsicher – sie spiegeln den Zustand zu einem bestimmten Zeitpunkt seit der Erstellung des Iterators/der Aufzählung wider;Dies ermöglicht gleichzeitige Lesevorgänge und Änderungen auf Kosten einer verringerten Konsistenz.Sie lösen keine ConcurrentModificationException aus.Iteratoren sind jedoch so konzipiert, dass sie jeweils nur von einem Thread verwendet werden können.

• Wie Hashtable aber nicht wie HashMap, diese Klasse lässt nicht zu, dass Null als Schlüssel oder Wert verwendet wird.

public static void main(String[] args) {

    //HashMap<String, Integer> hash = new HashMap<String, Integer>();
    Hashtable<String, Integer> hash = new Hashtable<String, Integer>();
    //ConcurrentHashMap<String, Integer> hash = new ConcurrentHashMap<>();

    new Thread() {
        @Override public void run() {
            try {
                for (int i = 10; i < 20; i++) {
                    sleepThread(1);
                    System.out.println("T1 :- Key"+i);
                    hash.put("Key"+i, i);
                }
                System.out.println( System.identityHashCode( hash ) );
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();
    new Thread() {
        @Override public void run() {
            try {
                sleepThread(5);
                // ConcurrentHashMap  traverse using Iterator, Enumeration is Fail-Safe.

                // Hashtable traverse using Enumeration is Fail-Safe, Iterator is Fail-Fast.
                for (Enumeration<String> e = hash.keys(); e.hasMoreElements(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ e.nextElement());
                }

                // HashMap traverse using Iterator, Enumeration is Fail-Fast.
                /*
                for (Iterator< Entry<String, Integer> > it = hash.entrySet().iterator(); it.hasNext(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ it.next());
                    // ConcurrentModificationException at java.util.Hashtable$Enumerator.next
                }
                */

                /*
                Set< Entry<String, Integer> > entrySet = hash.entrySet();
                Iterator< Entry<String, Integer> > it = entrySet.iterator();
                Enumeration<Entry<String, Integer>> entryEnumeration = Collections.enumeration( entrySet );
                while( entryEnumeration.hasMoreElements() ) {
                    sleepThread(1);
                    Entry<String, Integer> nextElement = entryEnumeration.nextElement();
                    System.out.println("T2 : "+ nextElement.getKey() +" : "+ nextElement.getValue() );
                    //java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode
                    //                                          at java.util.HashMap$EntryIterator.next
                    //                                          at java.util.Collections$3.nextElement
                }
                */
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();

    Map<String, String> unmodifiableMap = Collections.unmodifiableMap( map );
    try {
        unmodifiableMap.put("key4", "unmodifiableMap");
    } catch (java.lang.UnsupportedOperationException e) {
        System.err.println("UnsupportedOperationException : "+ e.getMessage() );
    }
}
static void sleepThread( int sec ) {
    try {
        Thread.sleep( 1000 * sec );
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

« Nullschlüssel und Nullwerte

HashMap erlaubt maximal einen Nullschlüssel und eine beliebige Anzahl von Nullwerten.Wohingegen Hashtable lässt nicht einmal einen einzigen Nullschlüssel und Nullwert zu. Wenn der Schlüssel oder Wert null ist, wird eine NullPointerException ausgelöst. ^Beispiel

« Synchronisiert, Thread-sicher

Hashtable ist intern synchronisiert.Daher ist die Verwendung sehr sicher Hashtable in Multithread-Anwendungen.Wohingegen HashMap ist nicht intern synchronisiert.Daher ist die Verwendung nicht sicher HashMap in Multithread-Anwendungen ohne externe Synchronisation.Sie können extern synchronisieren HashMap verwenden Collections.synchronizedMap() Methode.

« Leistung

Als Hashtable ist intern synchronisiert, das macht Hashtable etwas langsamer als die HashMap.

---

@Sehen

• Ein Rot-Schwarz-Baum ist eine Art selbstausgleichender binärer Suchbaum
• Leistungsverbesserung für HashMap in Java 8

Answer 18

Bei Thread-Apps können Sie häufig mit ConcurrentHashMap auskommen – abhängig von Ihren Leistungsanforderungen.

Answer 19

1.Hashmap Und HashTable Beide speichern Schlüssel und Wert.

2.Hashmap kann einen Schlüssel als speichern null. Hashtable Kann nicht gespeichert werden null.

3.HashMap ist aber nicht synchronisiert Hashtable synchronisiert ist.

4.HashMap kann mit synchronisiert werden Collection.SyncronizedMap(map)

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);

Answer 20

Abgesehen von den bereits erwähnten Unterschieden ist zu beachten, dass seit Java 8 HashMap Ersetzt die in jedem Bucket verwendeten Knoten (verknüpfte Liste) dynamisch durch TreeNodes (rot-schwarzer Baum), sodass auch bei hohen Hash-Kollisionen der schlimmste Fall auftritt beim Suchen Ist

O(log(n)) für HashMap Vs O(n) in Hashtable.

*Die oben genannte Verbesserung wurde nicht angewendet Hashtable noch, aber nur zu HashMap, LinkedHashMap, Und ConcurrentHashMap.

Zu Ihrer Information, derzeit

• TREEIFY_THRESHOLD = 8 :Wenn ein Bucket mehr als 8 Knoten enthält, wird die verknüpfte Liste in einen ausgeglichenen Baum umgewandelt.
• UNTREEIFY_THRESHOLD = 6 :Wenn ein Bucket zu klein wird (aufgrund von Entfernung oder Größenänderung), wird der Baum wieder in eine verknüpfte Liste umgewandelt.

Answer 21

Es gibt 5 grundlegende Unterscheidungen bei HashTable und HashMaps.

1. Mit Maps können Sie auch Schlüssel, Werte und beide Schlüssel-Wert-Paare iterieren und abrufen, während HashTable nicht über alle diese Funktionen verfügt.
2. In Hashtable gibt es eine Funktion enthält (), deren Verwendung sehr verwirrend ist.Weil die Bedeutung von enthält leicht abweicht.Ob es bedeutet, dass es einen Schlüssel enthält oder einen Wert enthält?schwer zu verstehen.Dasselbe gilt für Maps mit den Funktionen „ContainsKey()“ und „ContainsValue()“, die sehr einfach zu verstehen sind.
3. In Hashmap können Sie Elemente während der Iteration sicher entfernen.wo es in Hashtabellen nicht möglich ist.
4. HashTables sind standardmäßig synchronisiert, sodass sie problemlos mit mehreren Threads verwendet werden können.Da HashMaps standardmäßig nicht synchronisiert sind, können sie daher nur mit einem einzelnen Thread verwendet werden.Sie können HashMap jedoch weiterhin in synchronisiert konvertieren, indem Sie die Funktion „synchonizedMap(Map m)“ der Collections-Util-Klasse verwenden.
5. HashTable lässt keine Nullschlüssel oder Nullwerte zu.Wobei HashMap einen Nullschlüssel und mehrere Nullwerte zulässt.

Answer 22

Mein kleiner Beitrag:

1. Erster und wichtigster Unterschied zwischen Hashtable Und HashMap ist das, HashMap ist währenddessen nicht threadsicher Hashtable ist eine threadsichere Sammlung.

2. Zweiter wichtiger Unterschied zwischen Hashtable Und HashMap ist Leistung, da HashMap Wenn es nicht synchronisiert ist, ist die Leistung besser als Hashtable.

3. Dritter Unterschied Hashtable vs HashMap ist das Hashtable ist eine veraltete Klasse und Sie sollten sie verwenden ConcurrentHashMap anstelle von Hashtable in Java.

Answer 23

Hash-tabelle ist eine Legacy-Klasse im JDK, die nicht mehr verwendet werden sollte.Ersetzen Sie die Verwendungen davon durch ConcurrentHashMap.Wenn Sie keine Thread-Sicherheit benötigen, verwenden Sie HashMap was nicht der Fall ist Threadsicher aber schneller und verbraucht weniger Speicher.

Answer 24

1)Hashtable ist synchronisiert, Hashmap jedoch nicht.2) Ein weiterer Unterschied besteht darin, dass der Iterator in der HashMap ausfallsicher ist, während dies beim Enumerator für die Hashtable nicht der Fall ist.Wenn Sie die Karte während der Iteration ändern, wissen Sie es.

3)HashMap lässt darin Nullwerte zu, Hashtable hingegen nicht.

Answer 25

HashMap und HashTable

• Einige wichtige Punkte zu HashMap und HashTable.Bitte lesen Sie die folgenden Details.

1) Hashtable und Hashmap implementieren die java.util.Map-Schnittstelle 2) Sowohl Hashmap als auch Hashtable ist die Hash-basierte Sammlung.und arbeite am Hashing.Es handelt sich also um Ähnlichkeiten zwischen HashMap und HashTable.

• Was ist der Unterschied zwischen HashMap und HashTable?

1) Der erste Unterschied besteht darin, dass HashMap nicht Thread-sicher ist, während HashTable ThreadSafe ist
2) HashMap ist leistungsmäßig besser, da es nicht threadsicher ist.Während die Leistung von Hashtable nicht besser ist, da es Thread-sicher ist.Daher können nicht mehrere Threads gleichzeitig auf Hashtable zugreifen.

Answer 26

HashMap:Es handelt sich um eine Klasse, die im Paket java.util verfügbar ist und zum Speichern des Elements im Schlüssel- und Wertformat verwendet wird.

Hash-tabelle:Es handelt sich um eine Legacy-Klasse, die innerhalb des Collection-Frameworks erkannt wird.

Answer 27

Hashtable:

Hash-tabelle ist eine Datenstruktur, die Werte eines Schlüssel-Wert-Paares behält.Es ist weder für die Schlüssel noch für die Werte Null zulässig.Du bekommst ein NullPointerException wenn Sie einen Nullwert hinzufügen.Es ist synchronisiert.Es ist also mit Kosten verbunden.Nur ein Thread kann darauf zugreifen Hash-tabelle zu einem bestimmten Zeitpunkt.

Beispiel :

import java.util.Map;
import java.util.Hashtable;

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states= new Hashtable<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    //will throw NullPointerEcxeption at runtime

    System.out.println(states.get(1));
    System.out.println(states.get(2));
//  System.out.println(states.get(3));

    }
}

HashMap:

HashMap ist wie Hash-tabelle Es werden aber auch Schlüsselwertpaare akzeptiert.Es erlaubt null sowohl für die Schlüssel als auch für die Werte.Seine Leistung ist besser als HashTable, denn es ist unsynchronized.

Beispiel:

import java.util.HashMap;
import java.util.Map;

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states = new HashMap<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    // Okay
    states.put(null,"UK");

    System.out.println(states.get(1));
    System.out.println(states.get(2));
    System.out.println(states.get(3));

    }
}

Answer 28

HashMaps gibt Ihnen die Freiheit der Synchronisierung und das Debuggen wird viel einfacher

Answer 29

HashMap wird emuliert und ist daher in verwendbar GWT client code wohingegen Hashtable ist nicht.

Answer 30

Synchronisierung oder Thread-sicher :

Hash Map ist nicht synchronisiert und daher nicht Thred-sicher und kann ohne ordnungsgemäß synchronisierten Block nicht von mehreren Threads gemeinsam genutzt werden, wohingegen Hashtable synchronisiert und daher Thread-sicher ist.

Nullschlüssel und Nullwerte :

HashMap erlaubt einen Nullschlüssel und eine beliebige Anzahl von Nullwerten. Hashtable lässt keine Nullschlüssel oder -werte zu.

Iterieren der Werte:

Der Iterator in der HashMap ist ein ausfallsicherer Iterator, während der Enumerator für die Hashtable dies nicht ist, und löst eine ConcurrentModificationException aus, wenn ein anderer Thread die Map strukturell ändert, indem er ein Element außer der eigenen Methode „remove()“ des Iterators hinzufügt oder entfernt.

Superklasse und Legacy :

HashMap ist eine Unterklasse der AbstractMap-Klasse, während Hashtable eine Unterklasse der Dictionary-Klasse ist.

Leistung :

Da HashMap nicht synchronisiert ist, ist es im Vergleich zu Hashtable schneller.

Verweisen http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java für Beispiele und Interviewfragen und Quiz im Zusammenhang mit der Java-Sammlung