Differenze tra HashMap e Hashtable?

Nota che molte delle risposte affermano che Hashtable è sincronizzato. In pratica questo ti compra molto poco. La sincronizzazione è sui metodi accessor / mutator interromperà due thread aggiungendo o rimuovendo dalla mappa contemporaneamente, ma nel mondo reale sarà spesso necessaria una sincronizzazione aggiuntiva.

Un idioma molto comune è "check then put" - cioè cercare una voce nella mappa e aggiungerla se non esiste già. Questa non è in alcun modo un'operazione atomica se si utilizza Hashtable o HashMap.

Una HashMap sincronizzata equivalentemente può essere ottenuta da:

Collections.synchronizedMap(myMap);

Ma per implementare correttamente questa logica è necessario sincronizzazione aggiuntiva del modulo:

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

Anche iterando su voci di una Hashtable (o una HashMap ottenuta da Raccolte.synchronizedMap) non è thread safe a meno che non si protegga anche la mappa dalla modifica tramite sincronizzazione aggiuntiva.

Implementazioni del ConcurrentMap interfaccia (ad esempio ConcurrentHashMap) risolvere alcuni di questi includendo thread safe check-then-act semantica come ad esempio:

ConcurrentMap.putIfAbsent(key, value);

Hashtable è considerato codice legacy. Non c'è nulla su Hashtable che non possa essere fatto usando HashMap o derivazioni di HashMap, quindi per il nuovo codice, non vedo alcuna giustificazione per tornare a Hashtable.

Questa domanda viene spesso posta in un'intervista per verificare se il candidato comprende l'uso corretto delle classi di raccolta ed è a conoscenza delle soluzioni alternative disponibili.

1. La classe HashMap è approssimativamente equivalente a Hashtable, tranne che non è sincronizzata e consente null. (HashMap consente valori null come chiave e valore mentre Hashtable non consente null).
2. HashMap non garantisce che l'ordine della mappa rimanga costante nel tempo.
3. HashMap è non sincronizzato mentre Hashtable è sincronizzato.
4. Iterator in HashMap è fail-safe mentre l'enumeratore per Hashtable non lo è e lancia ConcurrentModificationException se qualsiasi altro thread modifica strutturalmente la mappa aggiungendo o rimuovendo qualsiasi elemento tranne il metodo remove() di Iterator. Ma questo non è un comportamento garantito e sarà fatto da JVM al meglio.

Nota su alcuni termini importanti

1. Sincronizzato significa che solo un thread può modificare una tabella hash in un punto del tempo. Fondamentalmente, significa che qualsiasi thread prima di eseguire un aggiornamento su un hashtable dovrà acquisire un blocco sull'oggetto mentre altri attenderanno il rilascio di lock.
2. Fail-safe è rilevante dal contesto degli iteratori. Se un iteratore è stato creato su un oggetto collection e qualche altro thread tenta di modificare l'oggetto collection "strutturalmente", verrà generata un'eccezione di modifica concorrente. È possibile per altri thread però invocare il metodo " set " poiché non modifica la raccolta "strutturalmente". Tuttavia, se prima di chiamare "set", la raccolta è stata modificata strutturalmente, verrà generata" IllegalArgumentException".
3. Modifica strutturale significa eliminare o inserire un elemento che potrebbe effettivamente cambiare la struttura della mappa.

HashMap può essere sincronizzato da

Map m = Collections.synchronizeMap(hashMap);

Map fornisce viste di raccolta invece del supporto diretto per l'iterazione tramite enumerazione oggetto. Le viste di raccolta migliorano notevolmente espressività dell'interfaccia, come discusso più avanti in questa sezione. Map consente di iterare su chiavi, valori o coppie chiave-valore; Hashtable non fornisce la terza opzione. Mappa fornisce un modo sicuro per rimuovere le voci nel bel mezzo dell'iterazione; Hashtable no. Infine, Map corregge una carenza minore nell'interfaccia Hashtable. Hashtable ha un metodo chiamato contains, che restituisce true se il Hashtable contiene un dato valore. Dato il suo nome, ti aspetteresti questo metodo per restituire true se la Hashtable conteneva una data chiave, perché la chiave è il meccanismo di accesso principale per un Hashtable. mappa interfaccia elimina questa fonte di confusione rinominando il metodo containsValue. Inoltre, questo migliora la coerenza dell'interfaccia - containsValue parallels containsKey.

L'interfaccia della mappa

HashMap: Un'implementazione dell'interfaccia Map che utilizza i codici hash per indicizzare un array. Hashtable: Ciao, 1998 chiamato. Vogliono le loro collezioni API indietro.

Seriamente però, è meglio stare lontano da Hashtable del tutto. Per le app a thread singolo, non è necessario il sovraccarico aggiuntivo della sincronizzazione. Per le app altamente simultanee, la sincronizzazione paranoica potrebbe portare a fame, deadlock o pause di garbage collection non necessarie. Come Tim Howland ha sottolineato, si potrebbe usa invece ConcurrentHashMap.

Tieni presente che HashTable era una classe legacy prima dell'introduzione di Java Collections Framework (JCF) ed è stata successivamente adattata per implementare l'interfaccia Map. Così è stato Vector e Stack.

Pertanto, stai sempre lontano da loro nel nuovo codice poiché c'è sempre un'alternativa migliore nel JCF come altri avevano sottolineato.

Ecco il Java collection cheat sheet che troverai utile. Si noti che il blocco grigio contiene la classe legacy HashTable, Vector e Stack.

Oltre a ciò che izb ha detto, HashMap consente valori nulli, mentre Hashtable non lo fa.

Si noti inoltre che Hashtable estende la classe Dictionary, che come stato Javadocs , è obsoleta ed è stata sostituita dall'interfaccia Map.

Dai un'occhiata a questo grafico. Fornisce confronti tra diverse strutture di dati insieme a HashMap e Hashtable. Il confronto è preciso, chiaro e facile da capire.

Matrice di raccolta Java

Hashtable è simile a HashMap e ha un'interfaccia simile. Si consiglia di utilizzare HashMap, a meno che non sia necessario il supporto per le applicazioni legacy o sia necessaria la sincronizzazione, poiché i metodi Hashtables sono sincronizzati. Quindi, nel tuo caso, poiché non sei multi-threading, HashMaps è la soluzione migliore.

Ci sono molte buone risposte già pubblicate. Sto aggiungendo alcuni nuovi punti e riassumendo.

HashMap e Hashtable entrambi sono usati per memorizzare i dati nella forma chiave e valore. Entrambi utilizzano la tecnica di hashing per memorizzare chiavi univoche. Ma ci sono molte differenze tra le classi HashMap e Hashtable che vengono fornite di seguito.

HashMap

1. HashMap non è sincronizzato. Non è sicuro per i thread e non può essere condiviso tra molti thread senza una corretta codice di sincronizzazione.
2. HashMap consente una chiave null e più valori null.
3. HashMap è una nuova classe introdotta in JDK 1.2.
4. HashMap è veloce.
5. Possiamo rendere il HashMap come sincronizzato chiamando questo codice
   Map m = Collections.synchronizedMap(HashMap);
6. HashMap è attraversato da Iteratore.
7. Iteratore in HashMap è fail-fast.
8. HashMap eredita la classe AbstractMap.

Hashtable

1. Hashtable è sincronizzato. È thread-safe e può essere condiviso con molti thread.
2. Hashtable non consente alcuna chiave o valore null.
3. Hashtable è una classe legacy.
4. Hashtable è lento.
5. Hashtable è sincronizzato internamente e non può essere non sincronizzato.
6. Hashtable è attraversato da Enumeratore e Iteratore.
7. Enumeratore in Hashtable non è fail-fast.
8. Hashtable eredita la classe Dictionary.

Ulteriori letture Qual è la differenza tra HashMap e Hashtable in Java?

Un'altra differenza fondamentale tra hashtable e hashmap è che l'Iteratore in HashMap è fail-fast mentre l'enumeratore per Hashtable non lo è e lancia ConcurrentModificationException se qualsiasi altro thread modifica strutturalmente la mappa aggiungendo o rimuovendo qualsiasi elemento tranne il metodo remove() di Iterator. Ma questo non è un comportamento garantito e sarà fatto da JVM al meglio."

La mia fonte: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html

Oltre a tutti gli altri aspetti importanti già menzionati qui, l'API delle collezioni (ad esempio l'interfaccia della mappa) viene modificata continuamente per conformarsi alle "ultime e più grandi" aggiunte alle specifiche Java.

Ad esempio, confrontare Java 5 Mappa iterazione:

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

Rispetto al vecchio approccio Hashtable:

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

In Java 1.8 ci viene anche promesso di essere in grado di costruire e accedere alle HASHMAP come nei buoni vecchi linguaggi di scripting:

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

Aggiornamento: No, non lo faranno atterrare in 1.8... :(

I miglioramenti della collezione di Project Coin saranno in JDK8?

• HashTable è sincronizzato, se lo si utilizza in un singolo thread è possibile utilizzare HashMap , che è una versione non sincronizzata. Gli oggetti non sincronizzati sono spesso un po ' più performanti. A proposito, se più thread accedono contemporaneamente a una HashMap e almeno uno dei thread modifica strutturalmente la mappa, deve essere sincronizzato esternamente. Puoi avvolgere una mappa non sincronizzata in una sincronizzata usando:

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

• HashTable può solo contiene un oggetto non nullo come chiave o come valore. HashMap può contenere una chiave null e valori null.

• Gli iteratori restituiti da Map sono fail-fast, se la mappa viene modificata strutturalmente in qualsiasi momento dopo la creazione dell'iteratore, in qualsiasi modo tranne attraverso il metodo remove dell'iteratore, l'iteratore genererà un ConcurrentModificationException. Pertanto, di fronte alla modifica concorrente, l'iteratore fallisce rapidamente e in modo pulito, piuttosto che rischiare un comportamento arbitrario e non deterministico a un indeterminato tempo nel futuro. Mentre le enumerazioni restituite dai metodi chiavi ed elementi di Hashtable non sono fail-fast.

• HashTable e HashMap sono membri del framework Java Collections (dalla piattaforma Java 2 v1.2, HashTable è stato adattato per implementare l'interfaccia Map).

• HashTable è considerato codice legacy, la documentazione consiglia di utilizzare ConcurrentHashMap al posto di Hashtable se un thread-safe altamente concorrente l'implementazione è desiderata.

• HashMap non garantisce l'ordine in cui gli elementi vengono restituiti. Per HashTable immagino che sia lo stesso, ma non sono del tutto sicuro, non trovo ressource che lo affermi chiaramente.

HashMap e Hashtable hanno anche significative differenze algoritmiche. Nessuno ha menzionato questo prima, quindi è per questo che lo sto sollevando. HashMap costruirà una tabella hash con potenza di due dimensioni, la aumenterà dinamicamente in modo tale da avere al massimo circa otto elementi (collisioni) in qualsiasi bucket e mescolerà gli elementi molto bene per i tipi di elementi generali. Tuttavia, l'implementazione Hashtable fornisce un controllo migliore e più preciso sull'hashing se si sa cosa si sta facendo, ovvero è possibile correggere la dimensione della tabella usando ad esempio il numero primo più vicino alla dimensione del dominio dei valori e questo si tradurrà in prestazioni migliori di HashMap, cioè meno collisioni per alcuni casi.

A parte le ovvie differenze discusse ampiamente in questa domanda, vedo l'Hashtable come un'auto "manuale" in cui si ha un migliore controllo sull'hashing e l'HashMap come la controparte "automatica" che generalmente funzionerà bene.

Hashtable è sincronizzato, mentre HashMap non lo è. Ciò rende Hashtable più lento di Hashmap.

Per le app non filettate, usa HashMap poiché sono altrimenti uguali in termini di funzionalità.

In base alle informazioni qui , consiglierei di andare con HashMap. Penso che il più grande vantaggio sia che Java ti impedirà di modificarlo mentre lo stai iterando, a meno che tu non lo faccia attraverso l'iteratore.

Per le app con thread, spesso è possibile farla franca con ConcurrentHashMap, a seconda dei requisiti di prestazioni.

A Collection - a volte chiamato un contenitore - è semplicemente un oggetto che raggruppa più elementi in una singola unità. Collections vengono utilizzati per archiviare, recuperare, manipolare e comunicare dati aggregati. Un quadro collezioni^C è un'architettura unificata per rappresentare e manipolare le collezioni.

Il HashMap JDK1.2 e Hashtable ^JDK1.0, entrambi sono usati per rappresentare un gruppo di oggetti rappresentati nella coppia <Key, Value>. Ogni coppia <Key, Value> è chiamata oggetto Entry. La raccolta di Voci è riferita dall'oggetto di HashMap e Hashtable. Le chiavi di una collezione devono essere uniche o distintive. [come vengono utilizzati per recuperare un valore mappato una particolare chiave. i valori in una raccolta possono essere duplicati.]

" Il sito utilizza cookie tecnici e di terze parti per migliorare la tua esperienza di navigazione.]}

Hashtable è una classe legacy introdotta in JDK1.0, che è una sottoclasse di classe Dizionario. From JDK1.2 Hashtable viene riprogettato per implementare l'interfaccia Map per creare un membro del framework di raccolta. HashMap è un membro di Java Collection Framework fin dall'inizio della sua introduzione in JDK1.2. HashMap è la sottoclasse della classe AbstractMap.

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 { ... }

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

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();
    }
}

Oltre alle differenze già menzionate, va notato che da Java 8, HashMap sostituisce dinamicamente i Nodi (elenco collegato) utilizzati in ciascun bucket con TreeNodes (albero rosso-nero), in modo che anche se esistono collisioni hash elevate, il caso peggiore durante la ricerca è

O(log(n)) per HashMap Vs O (n) in Hashtable.

* Il suddetto miglioramento non è stato ancora applicato a Hashtable, ma solo a HashMap, LinkedHashMap, e ConcurrentHashMap.

PER TUA INFORMAZIONE, attualmente,

• TREEIFY_THRESHOLD = 8 : se un bucket contiene più di 8 nodi, l'elenco collegato viene trasformato in un albero bilanciato.
• UNTREEIFY_THRESHOLD = 6 : quando un bucket diventa troppo piccolo (a causa della rimozione o del ridimensionamento), l'albero viene riconvertito in elenco collegato.

1.Hashmap e HashTable memorizzano sia la chiave che il valore.

2.Hashmap può memorizzare una chiave come null. Hashtable non può memorizzare null.

3.HashMap non è sincronizzato ma Hashtable è sincronizzato.

4.HashMap può essere sincronizzato con Collection.SyncronizedMap(map)

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);

Ci sono 5 differenziazioni di base con HashTable e HashMaps.

1. Maps consente di iterare e recuperare chiavi, valori ed entrambe le coppie chiave-valore, dove HashTable non ha tutte queste funzionalità.
2. In Hashtable c'è una funzione contains(), che è molto confusa da usare. Perché il significato di contiene è leggermente deviante. Se significa contiene chiave o contiene valore? difficile da capire. Stessa cosa nelle mappe che abbiamo ContainsKey () e Funzioni ContainsValue (), che sono molto facili da capire.
3. In hashmap è possibile rimuovere l'elemento durante l'iterazione, in modo sicuro. dove come non è possibile in hashtables.
4. Gli HashTables sono sincronizzati di default, quindi possono essere usati facilmente con più thread. Dove come HASHMAP non sono sincronizzati per impostazione predefinita, quindi può essere utilizzato con un solo thread. Ma puoi ancora convertire HashMap in sincronizzato usando Collections util class's synchronizedMap(Map m) funzione.
5. HashTable non consente chiavi null o valori null. Dove as HashMap consente una chiave null e più valori null.

Il mio piccolo contributo:

1. La prima e più significativa differenza tra Hashtable e HashMap è che HashMap non è thread-safe mentre Hashtable è una raccolta thread-safe.

2. La seconda importante differenza tra Hashtable e HashMap è la prestazione, poiché HashMap non è sincronizzato, funziona meglio di Hashtable.

3. La terza differenza su Hashtable vs HashMap è che Hashtable è una classe obsoleta e dovresti usare ConcurrentHashMap al posto di Hashtable in Java.

HashTable è una classe legacy nel jdk che non dovrebbe più essere utilizzata. Sostituisci gli usi di esso con ConcurrentHashMap . Se non si richiede la sicurezza del thread, utilizzare HashMap che non è threadsafe ma più veloce e utilizza meno memoria.

1)Hashtable è sincronizzato mentre hashmap non lo è. 2) Un'altra differenza è che l'iteratore nella HashMap è fail-safe mentre l'enumeratore per la Hashtable non lo è. Se cambi la mappa durante l'iterazione, lo saprai.

3)HashMap consente valori nulli in esso, mentre Hashtable non lo fa.

HashMap:- È una classe disponibile all'interno di java.pacchetto util e viene utilizzato per memorizzare l'elemento in formato chiave e valore.

Hashtable: - È una classe legacy che viene riconosciuta all'interno del framework di raccolta

Hashtable:

Hashtable è una struttura dati che conserva i valori della coppia chiave-valore. Non consente null sia per le chiavi che per i valori. Otterrai un NullPointerException se aggiungi valore null. È sincronizzato. Quindi viene fornito con il suo costo. Solo un thread può accedere a HashTable in un determinato momento.

Esempio :

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 è come Hashtable ma accetta anche la coppia di valori chiave. Esso consente null sia per le chiavi che per i valori. Le sue prestazioni migliori sono migliori di HashTable, perché è unsynchronized.

Esempio:

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

    }
}

HashMap e HashTable

• Alcuni punti importanti su HashMap e HashTable. si prega di leggere sotto i dettagli.

1) Hashtable e Hashmap implementano java.util.Interfaccia mappa 2) Sia Hashmap che Hashtable sono la raccolta basata su hash. e lavorando sull'hashing. quindi queste sono somiglianze tra HashMap e HashTable.

• Qual è la differenza tra HashMap e HashTable?

1) La prima differenza è che HashMap non è thread safe Mentre HashTable è ThreadSafe
2) HashMap è meglio in termini di prestazioni perché non è thread safe. mentre le prestazioni di Hashtable non sono migliori perché è thread safe. quindi più thread non possono accedere a Hashtable allo stesso tempo.

HashMaps ti dà la libertà di sincronizzazione e il debug è molto più facile

HashMap è emulato e quindi utilizzabile in GWT client code mentre Hashtable non lo è.

Sincronizzazione o Thread sicuro :

Hash Map non è sincronizzato, quindi non è thred safe e non può essere condiviso tra più thread senza un blocco sincronizzato appropriato, mentre Hashtable è sincronizzato e quindi è thread safe.

Chiavi null e valori null :

HashMap consente una chiave null e un numero qualsiasi di valori null.Hashtable non consente chiavi o valori null.

Iterazione dei valori:

Iteratore nel HashMap è un iteratore fail-fast mentre l'enumeratore per Hashtable non lo è e lancia ConcurrentModificationException se qualsiasi altro thread modifica strutturalmente la mappa aggiungendo o rimuovendo qualsiasi elemento tranne il metodo remove() di Iterator.

Superclasse e Legacy:

HashMap è sottoclasse della classe AbstractMap mentre Hashtable è sottoclasse della classe Dictionary.

Prestazioni :

Poiché HashMap non è sincronizzato, è più veloce rispetto a Hashtable.

Riferimento http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java per esempi e domande di intervista e quiz relativi alla raccolta Java