Differenza tra HashMap, LinkedHashMap e TreeMap

Qual è la differenza tra HashMap, LinkedHashMape TreeMapin Java? Non vedo alcuna differenza nell'output come tutti e tre hanno keySete values. Cosa sono le Hashtables?

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

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

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

Tutte e tre le classi implementano l' Mapinterfaccia e offrono principalmente la stessa funzionalità. La differenza più importante è l'ordine in cui avverrà l'iterazione attraverso le voci:

• HashMapnon fornisce alcuna garanzia circa l'ordine di iterazione. Può (e cambierà) completamente anche quando vengono aggiunti nuovi elementi.
• TreeMapeseguirà l'iterazione secondo l '"ordinamento naturale" delle chiavi secondo il loro compareTo()metodo (o fornito esternamente Comparator). Inoltre, implementa l' SortedMapinterfaccia, che contiene metodi che dipendono da questo tipo di ordinamento.
• LinkedHashMap itererà nell'ordine in cui le voci sono state inserite nella mappa

"Hashtable" è il nome generico per le mappe basate su hash. Nel contesto dell'API Java, Hashtableè una classe obsoleta dai tempi di Java 1.1 prima dell'esistenza del framework delle raccolte. Non dovrebbe più essere utilizzato, poiché la sua API è ingombra di metodi obsoleti che duplicano la funzionalità e i suoi metodi sono sincronizzati (che può ridurre le prestazioni ed è generalmente inutile). Utilizzare ConcurrentHashMap invece di Hashtable.

Preferisco la presentazione visiva:

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

Tutti e tre rappresentano il mapping da chiavi univoche a valori e quindi implementano l' interfaccia Mappa .

1. HashMap è una mappa basata su hashing delle chiavi. Supporta O (1) operazioni get / put. Le chiavi devono avere implementazioni coerenti hashCode()eequals() perché ciò funzioni.

2. LinkedHashMap è molto simile a HashMap, ma aggiunge consapevolezza all'ordine in cui gli elementi vengono aggiunti (o accessibili), quindi l'ordine di iterazione è uguale all'ordine di inserimento (o all'ordine di accesso, a seconda dei parametri di costruzione).

3. TreeMap è una mappatura basata su alberi. Le sue operazioni put / get richiedono tempo O (log n). Richiede che gli articoli abbiano un meccanismo di confronto, sia con Comparable che Comparator. L'ordine di iterazione è determinato da questo meccanismo.

Vedi dove si trova ciascuna classe nella gerarchia di classi nel seguente diagramma ( più grande ). TreeMap implementa SortedMape NavigableMapmentre HashMapno.

HashTableè obsoleto e ConcurrentHashMapdeve essere utilizzata la classe corrispondente .

HashMap

• Ha valori di coppia (chiavi, valori)
• NO valori chiave di duplicazione
• non ordinato non ordinato
• consente una chiave null e più di un valore null

HashTable

• come la mappa hash
• non consente chiavi null e valori null

LinkedHashMap

• Viene ordinata la versione dell'implementazione della mappa
• Basato su elenco collegato e strutture di dati di hashing

TreeMap

• Versione ordinata e ordinata
• basato su strutture di dati di hashing

Solo qualche ulteriore input dalla mia esperienza con le mappe, su quando avrei usato ciascuno di essi:

• HashMap - Utile soprattutto quando si cerca un'implementazione dalle prestazioni migliori (veloce).
• TreeMap (interfaccia SortedMap) - Utile soprattutto quando sono in grado di ordinare o scorrere le chiavi in ​​un ordine particolare che definisco.
• LinkedHashMap: unisce i vantaggi di un ordine garantito da TreeMap senza il costo aggiuntivo di gestione di TreeMap. (È quasi veloce come la HashMap). In particolare, LinkedHashMap fornisce anche un ottimo punto di partenza per la creazione di un oggetto Cache sostituendo il removeEldestEntry()metodo. Ciò consente di creare un oggetto Cache in grado di far scadere i dati utilizzando alcuni criteri definiti dall'utente.

Tutte e tre le classi HashMap, TreeMape LinkedHashMapimplementa java.util.Mapl'interfaccia, e rappresenta la mappatura da chiave unica di valori.

HashMap

1. A HashMapcontiene valori basati sulla chiave.

2. Contiene solo elementi unici.

3. Può avere una chiave null e più valori null.

4. Non mantiene alcun ordine .

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

LinkedHashMap

1. A LinkedHashMapcontiene valori basati sulla chiave.
2. Contiene solo elementi unici.
3. Può avere una chiave null e più valori null.

4. È lo stesso di HashMap invece mantiene l'ordine di inserimento . // Vedi la decelerazione della classe di seguito

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

TreeMap

1. A TreeMapcontiene valori basati sulla chiave. Implementa l'interfaccia NavigableMap ed estende la classe AbstractMap.
2. Contiene solo elementi unici.
3. Non può avere una chiave null ma può avere più valori null.

4. È lo stesso che HashMapinvece mantiene l' ordine crescente (Ordinato usando l'ordine naturale della sua chiave.).

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

tabella hash

1. Una Hashtable è una matrice di elenco. Ogni elenco è noto come un bucket. La posizione del bucket viene identificata chiamando il metodo hashcode (). Un Hashtable contiene valori basati sulla chiave.
2. Contiene solo elementi unici.
3. Potrebbe non avere alcuna chiave o valore null.
4. È sincronizzato .

5. È una classe legacy.

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

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

HashMap non fornisce assolutamente garanzie sull'ordine di iterazione. Può (e cambierà) completamente anche quando vengono aggiunti nuovi elementi. TreeMap eseguirà l'iterazione in base al "ordinamento naturale" delle chiavi in ​​base al loro metodo compareTo () (o un comparatore fornito esternamente). Inoltre, implementa l'interfaccia SortedMap, che contiene metodi che dipendono da questo ordinamento. LinkedHashMap eseguirà l'iterazione nell'ordine in cui le voci sono state inserite nella mappa

Guarda come le prestazioni variano ..

Mappa ad albero che è un'implementazione della mappa ordinata. La complessità dell'operazione put, get e IncludesKey è O (log n) dovuta all'ordinamento naturale

@Amit: SortedMapè un'interfaccia mentre TreeMapè una classe che implementa l' SortedMapinterfaccia. Ciò significa che se segue il protocollo che SortedMapchiede ai suoi implementatori di fare. Un albero a meno che non sia implementato come albero di ricerca, non può fornirti dati ordinati perché l'albero può essere qualsiasi tipo di albero. Quindi, per far funzionare TreeMap come Ordinato, implementa SortedMap (ad esempio, Albero di ricerca binario - BST, BST bilanciato come AVL e RB Tree, persino Albero di ricerca ternario - utilizzato principalmente per ricerche iterative in modo ordinato).

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

In NUT-SHELL HashMap: fornisce i dati in O (1), nessun ordine

TreeMap : fornisce i dati in O (log N), base 2. con le chiavi ordinate

LinkedHashMap: è una tabella hash con la lista di collegamenti (pensate alla indicizzata-SkipList) per archiviare i dati nel modo in cui vengono inseriti nella struttura. Più adatto per implementare LRU (usato meno di recente).

Di seguito sono riportate le principali differenze tra HashMap e TreeMap

1. HashMap non mantiene alcun ordine. In altre parole, HashMap non fornisce alcuna garanzia che l'elemento inserito per primo verrà stampato per primo, dove, proprio come TreeSet, anche gli elementi TreeMap sono ordinati in base all'ordinamento naturale dei suoi elementi

2. L'implementazione HashMap interna utilizza Hashing e TreeMap utilizza internamente l'implementazione dell'albero Red-Black.

3. HashMap può memorizzare una chiave null e molti valori null .reeMap non può contenere chiavi null ma può contenere molti valori null.

4. HashMap richiede prestazioni di tempo costanti per le operazioni di base come get e put, ovvero O (1). Secondo i documenti Oracle, TreeMap fornisce un costo di log (n) tempo garantito per il metodo get e put.

5. HashMap è molto più veloce di TreeMap, poiché il tempo di prestazioni di HashMap è costante rispetto al tempo di log TreeMap per la maggior parte delle operazioni.

6. HashMap utilizza il metodo equals () a confronto, mentre TreeMap utilizza il metodo compareTo () per mantenere l'ordinamento.

7. HashMap implementa l'interfaccia Map mentre TreeMap implementa l'interfaccia NavigableMap.

Queste sono implementazioni diverse della stessa interfaccia. Ogni implementazione presenta alcuni vantaggi e alcuni svantaggi (inserimento rapido, ricerca lenta) o viceversa.

Per i dettagli, guarda il javadoc di TreeMap , HashMap , LinkedHashMap .

La mappa hash non mantiene l'ordine di inserimento.
Esempio. Hashmap Se si inseriscono le chiavi come

1  3
5  9
4   6
7   15
3   10

Può archiviarlo come

4  6
5  9
3  10
1  3
7  15

Hashmap collegata mantiene l'ordine di inserimento.

Esempio.
Se si stanno inserendo le chiavi

1  3
5  9
4   6
7   15
3   10

Lo memorizzerà come

1  3
5  9
4   6
7   15
3   10

lo stesso che inseriamo.

La mappa ad albero memorizza i valori in Ordine crescente di chiavi. Esempio.
Se si stanno inserendo le chiavi

1  3
5  9
4   6
7   15
3   10

Lo memorizzerà come

1  3
3  10
4   6
5   9
7   15

• HashMap:

  • L'ordine non mantiene
  • Più veloce di LinkedHashMap
  • Utilizzato per archiviare un mucchio di oggetti

• LinkedHashMap:

  • L'ordine di inserimento di LinkedHashMap verrà mantenuto
  • Più lento di HashMap e più veloce di TreeMap
  • Se si desidera mantenere un ordine di inserzione, utilizzare questo.

• TreeMap:

  • TreeMap è una mappatura basata su alberi
  • TreeMap seguirà il naturale ordinamento della chiave
  • Più lento di HashMap e LinkedHashMap
  • Utilizzare TreeMap quando è necessario mantenere un ordinamento naturale (predefinito)

Tutti offrono una mappa chiave-> valore e un modo per scorrere le chiavi. La distinzione più importante tra queste classi sono le garanzie temporali e l'ordinamento delle chiavi.

1. HashMap offre 0 (1) ricerca e inserimento. Se si scorre attraverso le chiavi, tuttavia, l'ordinamento delle chiavi è essenzialmente arbitrario. È implementato da una serie di elenchi collegati.
2. TreeMap offre la ricerca e l'inserimento di O (log N). Le chiavi sono ordinate, quindi se è necessario scorrere le chiavi in ​​ordine ordinato, è possibile. Ciò significa che le chiavi devono implementare l'interfaccia Comparable.TreeMap è implementata da un albero rosso-nero.
3. LinkedHashMap offre 0 (1) ricerca e inserimento. Le chiavi sono ordinate in base al loro ordine di inserimento. È implementato da bucket doppiamente collegate.

Immagina di aver passato una TreeMap vuota, HashMap e LinkedHashMap nella seguente funzione:

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

L'output per ciascuno sarà simile ai risultati seguenti.

Per HashMap, nei miei test l'output era {0, 1, -1}, ma poteva essere qualsiasi ordinamento. Non esiste alcuna garanzia per l'ordinazione.
Treemap, l'output era, {-1, 0, 1}
LinkedList, l'output era, {1, -1, 0}

Mentre ci sono molte risposte eccellenti qui, vorrei presentare la mia tabella che descrive le varie Mapimplementazioni in bundle con Java 11.

Possiamo vedere queste differenze elencate nel grafico della tabella:

• HashMapè lo scopo generale Map comunemente usato quando non hai esigenze particolari.
• LinkedHashMapsi estende HashMap, aggiungendo questo comportamento: mantiene un ordine, l' ordine in cui le voci sono state originariamente aggiunte . La modifica del valore per l'immissione del valore-chiave non modifica la sua posizione nell'ordine.
• TreeMapAnche mantiene un ordine, ma usi (a) l' ordine “naturale” , che significa il valore del compareTometodo sul tasto di oggetti definiti sulla Comparableinterfaccia, o (b) invoca un'implementazione che fornisci. Comparator
  • TreeMapimplementa sia l' SortedMapinterfaccia, sia il suo successore, l' NavigableMapinterfaccia.
• NULL s: TreeMapfa non permettono una NULL come la chiave , mentre HashMape LinkedHashMapfanno.
  • Tutti e tre consentono NULL come valore.
• HashTableè legacy , da Java 1 . Sostituito dalla ConcurrentHashMapclasse. Citando il Javadoc: ConcurrentHashMapobbedisce alle stesse specifiche funzionali Hashtablee include le versioni dei metodi corrispondenti a ciascun metodo di Hashtable.

HashMap
può contenere una chiave null.

HashMap non mantiene alcun ordine.

TreeMap

TreeMap non può contenere alcuna chiave null.

TreeMap mantiene l'ordine crescente.

LinkedHashMap

LinkedHashMap può essere utilizzato per mantenere l'ordine di inserimento, su cui sono inserite le chiavi in ​​Map oppure può anche essere usato per mantenere un ordine di accesso, su cui si accede alle chiavi.

Esempi ::

1) HashMap map = new HashMap ();

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

2) Mappa TreeMap = new TreeMap ();

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

3) LinkedHashMap map = new LinkedHashMap ();

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

Il più importante tra tutti e tre è il modo in cui salvano l'ordine delle voci.

HashMap- Non salva l'ordine delle voci. per esempio.

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

LinkedHashMap: Salva l'ordine in cui sono state inserite le voci. per esempio:

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

TreeMap: Salva le voci in ordine crescente delle chiavi. per esempio:

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