Differenze tra HashMap e Hashtable?

https://stackoverflow.com/questions/40471

09-06-2019
|

Domanda

Quali sono le differenze tra a HashMap e un Hashtable a Giava?

Quale è più efficiente per le applicazioni senza thread?

Soluzione

Ci sono molte differenze tra HashMap E Hashtable in Giava:

Hashtable È sincronizzato, mentre HashMap non è.Questo fa HashMap meglio per le applicazioni senza thread, poiché gli oggetti non sincronizzati in genere funzionano meglio di quelli sincronizzati.
Hashtable non permette null chiavi o valori. HashMap ne consente uno null chiave e qualsiasi numero di null valori.
Una delle sottoclassi di HashMap è LinkedHashMap, quindi nel caso in cui desideri un ordine di iterazione prevedibile (che è l'ordine di inserimento per impostazione predefinita), potresti facilmente sostituire il HashMap per un LinkedHashMap.Non sarebbe così facile se lo stessi usando Hashtable.

Poiché la sincronizzazione non è un problema per te, lo consiglio HashMap.Se la sincronizzazione diventa un problema, puoi anche guardare ConcurrentHashMap.

Altri suggerimenti

Tieni presente che molte risposte affermano che Hashtable è sincronizzato. In pratica questo ti compra molto poco. La sincronizzazione avviene tramite i metodi di accesso/mutazione che impediranno l'aggiunta o la rimozione simultanea di due thread dalla mappa, ma nel mondo reale sarà spesso necessaria una sincronizzazione aggiuntiva.

Un modo di dire molto comune è "controlla e poi metti" - cioècercare una voce in Map, e aggiungilo se non esiste già.Questa non è in alcun modo un'operazione atomica se la usi Hashtable O HashMap.

Un equivalente sincronizzato HashMap può essere ottenuto 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 a Hashtable(o a HashMap ottenuto da Collections.synchronizedMap) non è thread-safe a meno che non si protegga anche il file Map dall'essere modificati attraverso un'ulteriore sincronizzazione.

Implementazioni del ConcurrentMap interfaccia (ad es ConcurrentHashMap) risolvi alcuni di questi problemi includendo semantica "check-then-act" thread-safe ad esempio:

ConcurrentMap.putIfAbsent(key, value);

Hashtable è considerato codice legacy.Non c'è niente in merito Hashtable questo non può 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 durante il colloquio per verificare se il candidato comprende l'utilizzo corretto delle classi di raccolta ed è a conoscenza delle soluzioni alternative disponibili.

La classe HashMap è più o meno equivalente a Hashtable, tranne per il fatto che non è sincronizzata e consente valori nulli.(HashMap consente valori null come chiave e valore mentre Hashtable non consente valori null).
HashMap non garantisce che l'ordine della mappa rimanga costante nel tempo.
HashMap non è sincronizzato mentre Hashtable è sincronizzato.
L'iteratore in HashMap è a prova di errore 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 delete() di Iterator.Ma questo non è un comportamento garantito e verrà eseguito da JVM con il massimo impegno.

Nota su alcuni termini importanti

Sincronizzato significa che solo un thread può modificare una tabella hash in un determinato momento.In sostanza significa che qualsiasi thread prima di eseguire un aggiornamento su una hashtable dovrà acquisire un lock sull'oggetto mentre gli altri attenderanno che il lock venga rilasciato.
Il fail-safe è rilevante dal contesto degli iteratori.Se è stato creato un iteratore su un oggetto di raccolta e qualche altro thread tenta di modificare l'oggetto di raccolta "strutturalmente", verrà lanciata un'eccezione di modifica simultanea.È possibile che altri thread invochino il metodo "set" poiché non modifica la raccolta "strutturalmente".Tuttavia, se prima di chiamare "set", la raccolta è stata modificata strutturalmente, verrà lanciata "IllegalArgumentException".
Modifica strutturalmente significa eliminare o inserire elementi che potrebbero effettivamente modificare la struttura della mappa.

HashMap può essere sincronizzato da

Map m = Collections.synchronizeMap(hashMap);

MAP fornisce viste di raccolta anziché supporto diretto per l'iterazione tramite oggetti di enumerazione.Le visualizzazioni della raccolta migliorano notevolmente l'espressività dell'interfaccia, come discusso più avanti in questa sezione.La mappa ti consente di scorrere chiavi, valori o coppie chiave-valore;Hashtable non fornisce la terza opzione.La mappa fornisce un modo sicuro per rimuovere le voci in mezzo all'iterazione;Hashtable no.Infine, Map risolve una piccola carenza nell'interfaccia Hashtable.Hashtable ha un metodo chiamato contiene, che restituisce vero se l'hashtable contiene un determinato valore.Dato il suo nome, ti aspetteresti che questo metodo restituisse vero se l'hashtable conteneva una determinata chiave, perché la chiave è il meccanismo di accesso primario per un hashtable.L'interfaccia della mappa elimina questa fonte di confusione rinominando il metodo contiene il valore.Inoltre, ciò migliora la coerenza dell'interfaccia: contiene parallelismi contiene il takeky.

L'interfaccia della mappa

HashMap:Un'implementazione del Map interfaccia che utilizza codici hash per indicizzare un array.Hashtable:Ciao, ho chiamato nel 1998.Vogliono indietro l'API delle loro raccolte.

Sul serio, però, è meglio starne alla larga 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 carenze, blocchi o pause inutili nella raccolta dei rifiuti.Come ha sottolineato Tim Howland, potresti usare ConcurrentHashMap Invece.

Tieni presente che HashTable era una classe legacy prima dell'introduzione di Java Collections Framework (JCF) e successivamente è stata adattata per implementare Map interfaccia.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 Foglio informativo della raccolta Java che troverai utile.Notare che il blocco grigio contiene la classe legacy HashTable,Vector e Stack.

enter image description here

Oltre a quanto detto da izb, HashMap consente valori nulli, mentre il Hashtable non.

Nota anche questo Hashtable estende il Dictionary classe, che come Javadoc stato, è obsoleto ed è stato sostituito dal Map interfaccia.

Ci sono molte buone risposte già pubblicate.Aggiungo alcuni nuovi punti e li riassumo.

HashMap E Hashtable entrambi sono usati per immagazzinare dati sotto forma di chiave e valore.Entrambi utilizzano la tecnica di hashing per memorizzare chiavi univoche.Ma ci sono molte differenze tra le classi HashMap e Hashtable riportate di seguito.

HashMap

HashMap non è sincronizzato.Non è thread-safe e non può essere condiviso tra molti thread senza un codice di sincronizzazione adeguato.
HashMap consente una chiave nulla e più valori nulli.
HashMap è una nuova classe introdotta in JDK 1.2.
HashMap è veloce.
Possiamo fare il HashMap come sincronizzato chiamando questo codice
Map m = Collections.synchronizedMap(HashMap);
HashMap è attraversato da Iterator.
Iteratore dentro HashMap è a prova di fallimento.
HashMap eredita la classe AbstractMap.

Tabella hash

Hashtable è sincronizzato.È thread-safe e può essere condiviso con molti thread.
Hashtable non consente alcuna chiave o valore nullo.
Hashtable è una classe legacy.
Hashtable è lento.
Hashtable è sincronizzato internamente e non può essere sincronizzato.
Hashtable è attraversato da Enumerator e Iterator.
Enumeratore in Hashtable non è a prova di errore.
Hashtable eredita la classe Dictionary.

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

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

Matrice di raccolta Java

Hashtable è simile a HashMap e ha un'interfaccia simile.Si consiglia di utilizzare HashMap, a meno che tu non richieda supporto per applicazioni legacy o abbia bisogno di sincronizzazione, come Hashtables i metodi sono sincronizzatiQuindi nel tuo caso, poiché non sei multi-threading, HashMaps sono la soluzione migliore.

Un'altra differenza fondamentale tra hashtable e hashmap è che Iterator 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 delete() di Iterator.Ma questo non è un comportamento garantito e verrà adottato da JVM con il massimo impegno."

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 Collections (ad es.Map Interface) viene continuamente modificato per conformarsi alle "ultime e migliori" aggiunte alle specifiche Java.

Ad esempio, confronta l'iterazione di Java 5 Map:

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 poter costruire e accedere a HashMap come nei buoni vecchi linguaggi di scripting:

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

Aggiornamento: No, non arriveranno nella 1.8...:(

I miglioramenti alla collezione di Project Coin saranno presenti in JDK8?

HashTable è sincronizzato, se lo stai utilizzando in un singolo thread puoi 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 sincronizzata esternamente.Puoi racchiudere una mappa non sincronizzata in una mappa sincronizzata usando:
```
Map m = Collections.synchronizedMap(new HashMap(...));
```
HashTable può contenere solo oggetti non nulli come chiave o come valore.HashMap può contenere una chiave nulla e valori nulli.
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 che attraverso il metodo di rimozione dell'iteratore, l'iteratore lancerà un ConcurrentModificationException.Pertanto, a fronte di modifiche simultanee, l’iteratore fallisce in modo rapido e pulito, piuttosto che rischiare un comportamento arbitrario e non deterministico in un momento futuro indeterminato. Mentre le enumerazioni restituite dai metodi delle chiavi e degli elementi di Hashtable non sono a prova di errore.
HashTable e HashMap sono membri di Framework delle raccolte Java (a partire dalla piattaforma Java 2 v1.2, HashTable è stato adattato per implementare l'interfaccia Map).
HashTable è considerato codice legacy, la documentazione consiglia di utilizzarlo ConcurrentHashMap al posto di Hashtable se si desidera un'implementazione altamente simultanea thread-safe.
HashMap non garantisce l'ordine in cui gli elementi vengono restituiti.Per HashTable immagino sia lo stesso ma non ne sono del tutto sicuro, non trovo risorse che lo affermino chiaramente.

HashMap E Hashtable presentano anche differenze algoritmiche significative.Nessuno ne ha parlato prima, ecco perché ne parlo. 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 ogni bucket e mescolerà gli elementi molto bene per i tipi di elementi generali.comunque, il Hashtable l'implementazione fornisce un controllo migliore e più preciso sull'hashing se sai cosa stai facendo, ovvero puoi correggere la dimensione della tabella usando ad es.il numero primo più vicino alla dimensione del dominio dei valori e ciò si tradurrà in prestazioni migliori rispetto ad HashMap, ad es.meno collisioni in alcuni casi.

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

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

Per le app senza thread, utilizza HashMap poiché per il resto sono le stesse in termini di funzionalità.

Sulla base delle informazioni Qui, consiglierei di utilizzare HashMap.Penso che il vantaggio più grande sia che Java ti impedirà di modificarlo mentre lo stai eseguendo, a meno che tu non lo faccia tramite l'iteratore.

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

IL HashMap ^JDK1.2 e Hashtable ^JDK1.0, entrambi vengono utilizzati per rappresentare un gruppo di oggetti rappresentati in <Key, Value> paio.Ogni <Key, Value> viene chiamata la coppia Entry oggetto.La raccolta di voci fa riferimento all'oggetto di HashMap E Hashtable.Le chiavi di una collezione devono essere uniche o distintive.[poiché vengono utilizzati per recuperare un valore mappato, una chiave particolare.i valori in una raccolta possono essere duplicati.]

« Membro di Superclass, Legacy e Collection Framework

Hashtable è una classe legacy introdotta in JDK1.0, che è una sottoclasse della classe Dictionary.Da JDK1.2 Hashtable è stato riprogettato per implementare il Interfaccia della mappa per diventare un membro del framework di raccolta.HashMap è 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 { ... }

« Capacità iniziale e fattore di carico

La capacità è il numero di contenitori nella tabella hash e la capacità iniziale è semplicemente la capacità al momento della creazione della tabella hash.Tieni presente che la tabella hash è aperta:nel caso di un "hashcollision", un singolo bucket memorizza più voci, che devono essere cercate in sequenza.Il fattore di carico è una misura di quanto è possibile riempire la tabella hash prima che la sua capacità venga aumentata automaticamente.

HashMap costruisce una tabella hash vuota con la capacità iniziale predefinita (16) e il fattore di carico predefinito (0,75).Dove as Hashtable costruisce una tabella hash vuota con una capacità iniziale predefinita (11) e rapporto fattore di carico/riempimento (0,75).

« Modifica strutturale in caso di collisione di hash

HashMap, Hashtable in caso di collisioni di hash memorizzano le voci della mappa in elenchi collegati. Da Java8 per HashMap se il bucket di hash cresce oltre una certa soglia, quel bucket passerà da linked list of entries to a balanced tree.che migliorano le prestazioni nel caso peggiore da O(n) a O(log n).Durante la conversione dell'elenco in albero binario, l'hashcode viene utilizzato come variabile di diramazione.Se ci sono due hashcode diversi nello stesso bucket, uno è considerato più grande e va a destra dell'albero e l'altro a sinistra.Ma quando entrambi gli hashcode sono uguali, HashMap presuppone che le chiavi siano comparabili e confronta la chiave per determinare la direzione in modo da poter mantenere un certo ordine.È buona pratica realizzare le chiavi HashMap paragonabile.Aggiunta di voci se la dimensione del bucket raggiunge TREEIFY_THRESHOLD = 8 convertire l'elenco collegato di voci in un albero bilanciato, rimuovendo le voci inferiori a TREEIFY_THRESHOLD e al massimo UNTREEIFY_THRESHOLD = 6 riconvertirà l'albero bilanciato in un elenco collegato di voci. ^{Java8 SRC, stackpost}

« Iterazione della visualizzazione della raccolta, Fail-Fast e Fail-Safe

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

Iterator è di natura fallimentare.cioè lancia ConcurrentModificationException se una raccolta viene modificata durante l'iterazione di un metodo diverso dal proprioremove().Mentre Enumeration è di natura fail-safe.Non genera eccezioni se una raccolta viene modificata durante l'iterazione.

Secondo Java API Docs, Iterator è sempre preferito rispetto a Enumeration.

_{NOTA: La funzionalità dell'interfaccia Enumerazione è duplicata dall'interfaccia Iterator.Inoltre, Iterator aggiunge un'operazione di rimozione opzionale e ha nomi di metodo più brevi.Le nuove implementazioni dovrebbero prendere in considerazione l'utilizzo di Iterator anziché Enumeration.}

In Java 5 ha introdotto l'interfaccia ConcurrentMap: ConcurrentHashMap - un sistema altamente simultaneo e ad alte prestazioni ConcurrentMap implementazione supportata da una tabella hash.Questa implementazione non si blocca mai durante l'esecuzione dei recuperi e consente al client di selezionare il livello di concorrenza per gli aggiornamenti.È inteso come sostituto immediato di Hashtable:oltre all'implementazione ConcurrentMap, supporta tutti i metodi "legacy" peculiari di Hashtable.

Ogni HashMapEntryIl valore è volatile garantendo così una consistenza a grana fine per le modifiche contestate e le letture successive;ogni lettura riflette l'aggiornamento completato più recentemente
Gli iteratori e le enumerazioni sono Fail Safe: riflettono lo stato a un certo punto dalla creazione dell'iteratore/enumerazione;ciò consente letture e modifiche simultanee al costo di una ridotta coerenza.Non lanciano ConcurrentModificationException.Tuttavia, gli iteratori sono progettati per essere utilizzati da un solo thread alla volta.
Come Hashtable ma diversamente HashMap, questa classe non consente l'utilizzo di null come chiave o valore.

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

« Chiavi nulle e valori nulli

HashMap consente al massimo una chiave nulla e un numero qualsiasi di valori nulli.Mentre Hashtable non consente nemmeno una singola chiave nulla e un valore nullo, se la chiave o il valore è nullo genera NullPointerException. ^Esempio

« Sincronizzato, thread-safe

Hashtable è sincronizzato internamente.Pertanto, è molto sicuro da usare Hashtable in applicazioni multi thread.Mentre HashMap non è sincronizzato internamente.Pertanto, non è sicuro da usare HashMap in applicazioni multi thread senza sincronizzazione esterna.È possibile eseguire la sincronizzazione esternamente HashMap utilizzando Collections.synchronizedMap() metodo.

« Prestazione

COME Hashtable è sincronizzato internamente, questo rende Hashtable leggermente più lento del HashMap.

@Vedere

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

1.Hashmap E HashTable entrambi memorizzano chiave e valore.

2.Hashmap può memorizzare una chiave come null. Hashtable non è possibile 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);

A parte le differenze già menzionate, va notato che a partire da Java 8, HashMap sostituisce dinamicamente i Nodes (elenco collegato) utilizzati in ciascun bucket con TreeNodes (albero rosso-nero), in modo che anche se esistono collisioni di hash elevate, il caso peggiore durante la ricerca È

O(log(n)) per HashMap Contro O(n) dentro Hashtable.

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

Per tua informazione, attualmente

TREEIFY_THRESHOLD = 8 :se un bucket contiene più di 8 nodi, la lista concatenata viene trasformata 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 un elenco collegato.

Esistono 5 differenziazioni di base con HashTable e HashMaps.

Maps ti consente di ripetere e recuperare chiavi, valori e anche entrambe le coppie chiave-valore, laddove HashTable non ha tutte queste funzionalità.
In Hashtable c'è una funzione contiene(), che è molto confusa da usare.Perché il significato di contiene è leggermente deviante.Se significa contiene chiave o contiene valore?difficile da capire.Stessa cosa in Maps abbiamo le funzioni ContieneKey() e ContieneValue(), che sono molto facili da capire.
In hashmap puoi rimuovere l'elemento durante l'iterazione, in sicurezza.dove non è possibile nelle tabelle hash.
Le tabelle Hash sono sincronizzate per impostazione predefinita, quindi possono essere utilizzate facilmente con più thread.Mentre gli HashMap non sono sincronizzati per impostazione predefinita, possono essere utilizzati con un solo thread.Ma puoi comunque convertire HashMap in sincronizzato utilizzando la funzione sincronizzata(Map m) della classe Collections util.
HashTable non consentirà chiavi null o valori null.Dove HashMap consente una chiave nulla e più valori nulli.

Il mio piccolo contributo:

Prima e più significativa differenza tra Hashtable E HashMap è questo, HashMap non è thread-safe while Hashtable è una raccolta thread-safe.

Seconda importante differenza tra Hashtable E HashMap è la prestazione, poiché HashMap non è sincronizzato funziona meglio di Hashtable.

Terza differenza su Hashtable contro HashMap è questo Hashtable è una classe obsoleta e dovresti usarla ConcurrentHashMap al posto di Hashtable a Giava.

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

1) Hashtable è sincronizzato mentre hashmap no.2) Un'altra differenza è che l'iteratore in HashMap è a prova di errore mentre l'enumeratore per Hashtable non lo è.Se cambi la mappa durante l'iterazione, lo saprai.

3) HashMap consente valori nulli, mentre Hashtable no.

HashMap e HashTable

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

1) Hashtable e hashmap implementano Java.util.map Interface 2) Sia hashmap che hashtable è la raccolta basata su hash.e lavorare 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 offre prestazioni migliori perché non è thread-safe.mentre le prestazioni di Hashtable non sono migliori perché è thread-safe.quindi più thread non possono accedere a Hashtable contemporaneamente.

Mappa hash:È una classe disponibile all'interno del pacchetto java.util e viene utilizzata per memorizzare l'elemento in formato chiave e valore.

Tabella hash:È una classe legacy che viene riconosciuta all'interno del framework della raccolta.

Hashtable:

Tabella hash è 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 un valore nullo.È sincronizzato.Quindi ha il suo costo.Può accedere solo un thread HashTable in un momento particolare.

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

    }
}

Mappa hash:

HashMap è come Tabella hash ma accetta anche coppie chiave-valore.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));

    }
}

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

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

Sincronizzazione o Thread Safe :

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

Chiavi nulle e valori nulli :

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

Iterazione dei valori:

Iterator in 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 delete() di Iterator.

Superclasse ed eredità :

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

Prestazione :

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

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

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow