method - java util hashtable get




Differenze tra HashMap e Hashtable? (20)

Quali sono le differenze tra una HashMap e una Hashtable in Java?

Quale è più efficiente per le applicazioni senza thread?


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

A parte le 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 esistano elevate collisioni di hash, il caso peggiore quando la ricerca è

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

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

FYI, 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.

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

HashMap e Hashtable sono entrambi utilizzati per memorizzare i dati in 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 fornite di seguito.

HashMap

  1. HashMap non è sincronizzato. Non è thread-safe e non può essere condiviso tra molti thread senza un codice di sincronizzazione adeguato.
  2. HashMap consente una chiave nullo e più valori nulli.
  3. HashMap è una nuova classe introdotta in JDK 1.2.
  4. HashMap è veloce.
  5. Possiamo rendere HashMap sincronizzato chiamando questo codice
    Map m = Collections.synchronizedMap(HashMap);
  6. HashMap è attraversato da Iterator.
  7. Iterator in HashMap è veloce.
  8. HashMap eredita la classe AbstractMap.

tabella hash

  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 Enumerator e Iterator.
  7. Enumerator in Hashtable non è fail-fast.
  8. Hashtable eredita la classe Dictionary.

Ulteriore lettura Qual è la differenza tra HashMap e Hashtable in Java?


Ci sono molte differenze tra HashMap e Hashtable in Java:

  1. Hashtable è synchronized , mentre HashMap no. Questo rende HashMap migliore per le applicazioni senza thread, in quanto gli oggetti non sincronizzati generalmente hanno prestazioni migliori rispetto a quelli sincronizzati.

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

  3. Una delle sottoclassi di LinkedHashMap è LinkedHashMap , quindi nel caso in cui si desideri un ordine di iterazione prevedibile (che è l'ordine di inserimento per impostazione predefinita), è possibile scambiare facilmente HashMap per una LinkedHashMap . Questo non sarebbe così facile se tu stessi usando Hashtable .

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


Esistono 5 differenziazioni di base con HashTable e HashMaps.

  1. Maps ti consente di ripetere e recuperare chiavi, valori e 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 che contiene chiave o contiene valore? difficile da capire. La stessa cosa in Maps abbiamo le funzioni ContainsKey () e ContainsValue (), che sono molto facili da capire.
  3. In hashmap puoi rimuovere l'elemento mentre si itera, in sicurezza. dove come non è possibile in hashtables.
  4. Le tabelle hash sono sincronizzate di default, quindi possono essere utilizzate facilmente con più thread. Dove come HashMaps non sono sincronizzati per impostazione predefinita, quindi può essere utilizzato con solo thread singolo. Ma puoi ancora convertire HashMap in modo sincronizzato usando la funzione synchronizedMap (Map m) delle Collections util class.
  5. HashTable non consentirà chiavi nulle o valori nulli. Dove come HashMap consente una chiave nullo e più valori nulli.

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

Per le app senza thread, usa HashMap poiché altrimenti sono le stesse in termini di funzionalità.


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

Un idioma molto comune è "controllare poi mettere", cioè cercare una voce nella mappa e aggiungerla se non esiste già. Questo non è in alcun modo un'operazione atomica se usi Hashtable o HashMap.

Una HashMap sincronizzata in modo equivalente può essere ottenuta da:

Collections.synchronizedMap(myMap);

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

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

Anche l'iterazione delle voci di Hashtable (o di una HashMap ottenuta da Collections.synchronizedMap) non è thread-safe a meno che non si protegga anche la Map dalla modifica tramite sincronizzazione aggiuntiva.

Le implementazioni dell'interfaccia ConcurrentMap (ad esempio ConcurrentHashMap ) risolvono alcune delle cose includendo la semantica di check-then-act thread safe come:

ConcurrentMap.putIfAbsent(key, value);

Per le app con thread, è spesso possibile farla franca con ConcurrentHashMap, in base ai requisiti di rendimento.


Sulla base delle informazioni here , ti consiglio di andare con HashMap. Penso che il più grande vantaggio sia che Java ti impedirà di modificarlo mentre stai iterando su di esso, a meno che non lo fai attraverso l'iteratore.


Tieni presente che HashTable era una classe legacy prima che Java Collections Framework (JCF) fosse introdotto e successivamente è stato riadattato per implementare l'interfaccia Map . Così è stato Vector and Stack .

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

Ecco il cheat della raccolta Java che troverai utile. Notare che il blocco grigio contiene la classe legacy HashTable, Vector e Stack.


HashTable è una classe legacy nel jdk che non dovrebbe essere più utilizzata. Sostituiscici l'utilizzo con ConcurrentHashMap . Se non si richiede la sicurezza del thread, utilizzare HashMap che non è threadsafe ma più veloce e utilizza meno memoria.


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

Seriamente, però, è meglio stare lontano da Hashtable . Per le app a thread singolo, non è necessario il sovraccarico extra della sincronizzazione. Per le applicazioni altamente concorrenti, la sincronizzazione paranoide potrebbe portare a carestie, deadlock o pause inutili di raccolta dei dati inutili. Come ha sottolineato Tim Howland, è possibile utilizzare ConcurrentHashMap .


HashMapè emulato e quindi utilizzabile GWT client codementre Hashtablenon lo è.


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


Una Collection , a volte chiamata contenitore, è semplicemente un oggetto che raggruppa più elementi in una singola unità. Collection vengono utilizzate per archiviare, recuperare, manipolare e comunicare dati aggregati. Un framework di collezioni W è un'architettura unificata per rappresentare e manipolare le raccolte.

HashMap JDK1.2 e Hashtable JDK1.0 , entrambi sono utilizzati per rappresentare un gruppo di oggetti rappresentati nella coppia <Key, Value> . Ogni coppia di <Key, Value> è chiamata Entry Item. La raccolta di voci è riferita dall'oggetto di HashMap e Hashtable . Le chiavi di una raccolta devono essere uniche o distintive. [come sono usati per recuperare un valore mappato di 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 è riprogettato per implementare l' interfaccia Map per creare 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 bucket nella tabella hash e la capacità iniziale è semplicemente la capacità al momento della creazione della tabella hash. Si noti che la tabella hash è aperta: nel caso di una " collision hash ", un singolo bucket memorizza più voci, che devono essere ricercate in sequenza. Il load factor è una misura di quanto è possibile ottenere la tabella hash prima che la sua capacità venga aumentata automaticamente.

HashMap crea una tabella hash vuota con la capacità iniziale predefinita (16) e il fattore di caricamento predefinito (0,75). Dove Hashtable costruisce l'hash vuoto con una capacità iniziale predefinita (11) e un rapporto fattore di riempimento / riempimento (0.75).

« Modifica strutturale in caso di collisione dell'hash

HashMap , Hashtable in caso di collisioni hash memorizzano le voci della mappa negli elenchi collegati. Da Java8 per HashMap se il bucket hash cresce oltre una determinata soglia, quel bucket passerà 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 un albero binario, l'hashcode viene utilizzato come variabile di diramazione. Se ci sono due diversi codici hash nello stesso bucket, uno viene considerato più grande e va a destra dell'albero e l'altro a sinistra. Ma quando entrambi gli hashcode sono uguali, HashMap presume che le chiavi siano comparabili e confronta la chiave per determinare la direzione in modo che un certo ordine possa essere mantenuto. È una buona pratica rendere le chiavi di HashMap comparable . TREEIFY_THRESHOLD = 8 voci se la dimensione del bucket raggiunge TREEIFY_THRESHOLD = 8 converti l'elenco di voci collegate in un albero bilanciato, alla rimozione di voci inferiori a TREEIFY_THRESHOLD e al massimo UNTREEIFY_THRESHOLD = 6 verrà riconvertito l'albero bilanciato nell'elenco di voci collegate. Java 8 SRC , stackpost

« Raccolta-visualizzazione iterazione, Fail-Fast e Fail-Safe

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

Iterator è di natura insuperabile. cioè getta ConcurrentModificationException se una collezione viene modificata mentre iterazione è diversa dal proprio metodo remove (). Dove come Enumeration è di natura fail-safe. Non genera eccezioni se una raccolta viene modificata durante l'iterazione.

Secondo Java API Docs, Iterator è sempre preferito rispetto all'Enumerazione.

NOTA: la funzionalità dell'interfaccia Enumeration viene 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 in preferenza su Enumeration.

In Java 5 è stata introdotta Interfaccia ConcurrentMap : ConcurrentHashMap : un'implementazione ConcurrentMap altamente concorrente e ad alte prestazioni supportata da una tabella hash. Questa implementazione non si blocca mai durante l'esecuzione di recuperi e consente al client di selezionare il livello di concorrenza per gli aggiornamenti. È inteso come una sostituzione drop-in per Hashtable : oltre all'implementazione di ConcurrentMap , supporta tutti i metodi "legacy" peculiari di Hashtable .

  • Ogni valore di HashMapEntry è volatile , garantendo così una consistenza a grana fine per le modifiche contese e le letture successive; ogni lettura riflette l'aggiornamento completato più di recente

  • Iteratori ed enumerazioni sono Fail Safe - riflettono lo stato ad un certo punto dalla creazione di iteratore / enumerazione; questo consente letture e modifiche simultanee al costo di una consistenza ridotta. Non generano ConcurrentModificationException. Tuttavia, gli iteratori sono progettati per essere utilizzati da un solo thread alla volta.

  • Come Hashtable ma a differenza di 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();
    }
}

« Null Keys And Null Values

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

« Sincronizzato, sicuro per i thread

Hashtable è sincronizzato internamente. Pertanto, è molto sicuro utilizzare Hashtable in applicazioni con più thread. Dove HashMap non è sincronizzato internamente. Pertanto, non è sicuro usare HashMap in applicazioni multi-thread senza sincronizzazione esterna. Puoi sincronizzare esternamente HashMap usando il metodo Collections.synchronizedMap() .

« Prestazioni

Poiché Hashtable è sincronizzato internamente, rende Hashtable leggermente più lento di HashMap .

@Vedere


Hashtable:

Hashtable è una struttura di dati che conserva i valori della coppia chiave-valore. Non consente null per entrambe le chiavi e i valori. Otterrai un valore NullPointerExceptionse aggiungi un valore nullo. È sincronizzato Quindi arriva 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 coppie di valori chiave. Permette null per entrambe le chiavi e i valori. Le sue prestazioni migliori sono migliori di HashTable, perché lo è 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));

    }
}

Sincronizzazione o discussione sicura :

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

Chiavi nulle e valori nulli :

HashMap consente una chiave nullo 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 la mappa strutturalmente aggiungendo o rimuovendo qualsiasi elemento tranne il metodo remove () di Iterator.

Superclasse e eredità :

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

Prestazioni :

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

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


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

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


Il mio piccolo contributo:

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

  2. La seconda importante differenza tra Hashtableed HashMapè la performance, dal momento che HashMapnon è sincronizzata, ha prestazioni migliori di Hashtable.

  3. La terza differenza su Hashtablevs HashMapè quella Hashtableclasse obsoleta e dovresti utilizzarla ConcurrentHashMapal posto di Hashtablein Java.


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

3) HashMap consente valori null in esso, mentre Hashtable no.





hashtable