Différence entre HashMap, LinkedHashMap et TreeMap

Quelle est la différence entre HashMap, LinkedHashMapet TreeMapen Java? Je ne vois aucune différence dans la sortie comme tous les trois a keySetet values. Quels sont 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());

Les trois classes implémentent l' Mapinterface et offrent principalement les mêmes fonctionnalités. La différence la plus importante est l'ordre dans lequel l'itération des entrées se produira:

• HashMapne fait absolument aucune garantie sur l'ordre d'itération. Il peut (et changera) même complètement lorsque de nouveaux éléments sont ajoutés.
• TreeMapitérera selon "l'ordre naturel" des clés selon leur compareTo()méthode (ou une source externe Comparator). De plus, il implémente l' SortedMapinterface, qui contient des méthodes qui dépendent de cet ordre de tri.
• LinkedHashMap va itérer dans l'ordre dans lequel les entrées ont été placées dans la carte

"Hashtable" est le nom générique des cartes basées sur le hachage. Dans le contexte de l'API Java, Hashtableest une classe obsolète datant de l'époque de Java 1.1 avant que le cadre des collections n'existe. Il ne devrait plus être utilisé, car son API est encombrée de méthodes obsolètes qui dupliquent les fonctionnalités et ses méthodes sont synchronisées (ce qui peut diminuer les performances et est généralement inutile). Utilisez ConcurrentHashMap au lieu de Hashtable.

Je préfère la présentation visuelle:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   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               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

Les trois représentent le mappage des clés uniques aux valeurs et implémentent donc l' interface Map .

1. HashMap est une carte basée sur le hachage des clés. Il prend en charge les opérations get / put O (1). Les clés doivent avoir des implémentations cohérentes de hashCode()etequals() pour que cela fonctionne.

2. LinkedHashMap est très similaire à HashMap, mais il ajoute la conscience à l'ordre auquel les éléments sont ajoutés (ou accédés), donc l'ordre d'itération est le même que l'ordre d'insertion (ou l'ordre d'accès, selon les paramètres de construction).

3. TreeMap est une cartographie basée sur un arbre. Ses opérations put / get prennent du temps O (log n). Il nécessite que les éléments disposent d'un mécanisme de comparaison, avec Comparable ou Comparator. L'ordre d'itération est déterminé par ce mécanisme.

Voyez où chaque classe se trouve dans la hiérarchie des classes dans le diagramme suivant (le plus grand ). TreeMap implémente SortedMapet NavigableMaptandis HashMapque non.

HashTableest obsolète et la ConcurrentHashMapclasse correspondante doit être utilisée.

HashMap

• Il a des valeurs de paire (clés, valeurs)
• AUCUNE valeur clé de duplication
• non trié non trié
• il autorise une clé nulle et plusieurs valeurs nulles

HashTable

• identique à la carte de hachage
• il n'autorise pas les clés nulles et les valeurs nulles

LinkedHashMap

• C'est la version ordonnée de l'implémentation de la carte
• Basé sur une liste chaînée et des structures de données de hachage

TreeMap

• Version commandée et triée
• basé sur des structures de données de hachage

Juste un peu plus de ma propre expérience avec les cartes, sur quand j'utiliserais chacune:

• HashMap - Plus utile lorsque vous recherchez une implémentation (rapide) aux meilleures performances.
• TreeMap (interface SortedMap) - Très utile lorsque je souhaite pouvoir trier ou itérer sur les clés dans un ordre particulier que je définis.
• LinkedHashMap - Combine les avantages d'une commande garantie depuis TreeMap sans augmenter le coût de maintenance de TreeMap. (Il est presque aussi rapide que le HashMap). En particulier, LinkedHashMap fournit également un excellent point de départ pour créer un objet Cache en remplaçant la removeEldestEntry()méthode. Cela vous permet de créer un objet Cache qui peut expirer des données en utilisant certains critères que vous définissez.

Tous les trois classes HashMap, TreeMapet LinkedHashMapmet en œuvre l' java.util.Mapinterface, et représente la cartographie de clé unique aux valeurs.

HashMap

1. A HashMapcontient des valeurs basées sur la clé.

2. Il ne contient que des éléments uniques.

3. Il peut avoir une clé null et plusieurs valeurs null.

4. Il ne maintient aucun ordre .

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

LinkedHashMap

1. A LinkedHashMapcontient des valeurs basées sur la clé.
2. Il ne contient que des éléments uniques.
3. Il peut avoir une clé null et plusieurs valeurs null.

4. C'est la même chose que HashMap maintient à la place l' ordre d'insertion . // Voir la décélération de classe ci-dessous

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

TreeMap

1. A TreeMapcontient des valeurs basées sur la clé. Il implémente l'interface NavigableMap et étend la classe AbstractMap.
2. Il ne contient que des éléments uniques.
3. Il ne peut pas avoir de clé nulle mais peut avoir plusieurs valeurs nulles.

4. Il est identique à la HashMapplace qui maintient l' ordre croissant (trié en utilisant l'ordre naturel de sa clé.).

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

Hashtable

1. Une table de hachage est un tableau de liste. Chaque liste est connue sous le nom de compartiment. La position du compartiment est identifiée en appelant la méthode hashcode (). Une table de hachage contient des valeurs basées sur la clé.
2. Il ne contient que des éléments uniques.
3. Il peut ne pas avoir de clé ou de valeur nulle.
4. Il est synchronisé .

5. Il s'agit d'une classe héritée.

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

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

HashMap ne fait absolument aucune garantie sur l'ordre d'itération. Il peut (et changera) même complètement lorsque de nouveaux éléments sont ajoutés. TreeMap va itérer selon "l'ordre naturel" des clés selon leur méthode compareTo () (ou un comparateur externe). En outre, il implémente l'interface SortedMap, qui contient des méthodes qui dépendent de cet ordre de tri. LinkedHashMap itérera dans l'ordre dans lequel les entrées ont été placées dans la carte

Regardez comment les performances varient ..

Carte arborescente qui est une implémentation de la carte triée. La complexité de l'opération put, get et containsKey est O (log n) en raison de l'ordre naturel

@Amit: SortedMapest une interface alors TreeMapqu'une classe qui implémente l' SortedMapinterface. Cela signifie que suit le protocole qui SortedMapdemande à ses implémenteurs de le faire. Un arbre, sauf s'il est implémenté comme arbre de recherche, ne peut pas vous donner de données ordonnées car l'arbre peut être n'importe quel type d'arbre. Donc, pour que TreeMap fonctionne comme l'ordre trié, il implémente SortedMap (par exemple, l'arbre de recherche binaire - BST, BST équilibré comme AVL et RB Tree, même l'arbre de recherche ternaire - principalement utilisé pour les recherches itératives de manière ordonnée).

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

En NUT-SHELL HashMap: donne des données en O (1), pas de classement

TreeMap : donne des données en O (log N), base 2. avec clés ordonnées

LinkedHashMap: est une table de hachage avec une capacité de liste liée (pensez à Indexed-SkipList) pour stocker les données de la manière dont elles sont insérées dans l'arborescence. Idéal pour implémenter LRU (utilisé le moins récemment).

Voici la différence majeure entre HashMap et TreeMap

1. HashMap ne maintient aucune commande. En d'autres termes, HashMap ne fournit aucune garantie que l'élément inséré en premier sera imprimé en premier, alors que, tout comme TreeSet, les éléments TreeMap sont également triés selon l'ordre naturel de ses éléments.

2. L'implémentation HashMap interne utilise Hashing et TreeMap utilise en interne l'implémentation arborescente Rouge-Noir.

3. HashMap peut stocker une clé nulle et plusieurs valeurs nulles. TreeMap ne peut pas contenir de clés nulles mais peut contenir de nombreuses valeurs nulles.

4. HashMap prend des performances à temps constant pour les opérations de base telles que get and put, c'est-à-dire O (1) .Selon Oracle docs, TreeMap fournit un coût en temps log (n) garanti pour la méthode get and put.

5. HashMap est beaucoup plus rapide que TreeMap, car le temps de performance de HashMap est constant par rapport au temps de journalisation TreeMap pour la plupart des opérations.

6. HashMap utilise la méthode equals () en comparaison tandis que TreeMap utilise la méthode compareTo () pour maintenir l'ordre.

7. HashMap implémente l'interface Map tandis que TreeMap implémente l'interface NavigableMap.

Ce sont différentes implémentations de la même interface. Chaque implémentation présente des avantages et des inconvénients (insertion rapide, recherche lente) ou vice versa.

Pour plus de détails, consultez le javadoc de TreeMap , HashMap , LinkedHashMap .

La carte de hachage ne conserve pas l'ordre d'insertion.
Exemple. Hashmap Si vous insérez des clés comme

1  3
5  9
4   6
7   15
3   10

Il peut le stocker sous

4  6
5  9
3  10
1  3
7  15

Hashmap lié préserve l'ordre d'insertion.

Exemple.
Si vous insérez des clés

1  3
5  9
4   6
7   15
3   10

Il le stockera sous

1  3
5  9
4   6
7   15
3   10

même que nous insérons.

La carte arborescente stocke les valeurs dans l'ordre croissant des clés. Exemple.
Si vous insérez des clés

1  3
5  9
4   6
7   15
3   10

Il le stockera sous

1  3
3  10
4   6
5   9
7   15

• HashMap:

  • L'ordre n'est pas maintenu
  • Plus rapide que LinkedHashMap
  • Utilisé pour stocker des tas d'objets

• LinkedHashMap:

  • L'ordre d'insertion de LinkedHashMap sera maintenu
  • Plus lent que HashMap et plus rapide que TreeMap
  • Si vous souhaitez conserver un ordre d'insertion, utilisez-le.

• TreeMap:

  • TreeMap est une cartographie basée sur un arbre
  • TreeMap suivra l'ordre naturel des clés
  • Plus lent que HashMap et LinkedHashMap
  • Utilisez TreeMap lorsque vous devez conserver un ordre naturel (par défaut)

Tous offrent une carte clé-> valeur et un moyen de parcourir les clés. La distinction la plus importante entre ces classes est la garantie de temps et la commande des clés.

1. HashMap propose 0 (1) recherche et insertion. Si vous parcourez les clés, cependant, l'ordre des clés est essentiellement arbitraire. Il est implémenté par un tableau de listes chaînées.
2. TreeMap offre la recherche et l'insertion O (log N). Les clés sont ordonnées, donc si vous devez parcourir les clés dans l'ordre trié, vous le pouvez. Cela signifie que les clés doivent implémenter l'interface Comparable.TreeMap est implémenté par un arbre rouge-noir.
3. LinkedHashMap offre la recherche et l'insertion 0 (1). Les clés sont classées par ordre d'insertion. Il est mis en œuvre par des compartiments à double liaison.

Imaginez que vous avez passé un TreeMap, HashMap et LinkedHashMap vide dans la fonction suivante:

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 + ", ");
  }
}

La sortie de chacun ressemblera aux résultats ci-dessous.

Pour HashMap, la sortie était, dans mes propres tests, {0, 1, -1}, mais cela pouvait être n'importe quel ordre. Il n'y a aucune garantie sur la commande.
Treemap, la sortie était, {-1, 0, 1}
LinkedList, la sortie était, {1, -1, 0}

Bien qu'il existe de nombreuses excellentes réponses ici, je voudrais présenter mon propre tableau décrivant les différentes Mapimplémentations fournies avec Java 11.

Nous pouvons voir ces différences répertoriées sur le graphique du tableau:

• HashMapest l' usage général Map couramment utilisé lorsque vous n'avez pas de besoins particuliers.
• LinkedHashMapétend HashMap, en ajoutant ce comportement: Gère un ordre, l' ordre dans lequel les entrées ont été ajoutées à l'origine . La modification de la valeur pour la saisie de valeur-clé ne modifie pas sa place dans l'ordre.
• TreeMapmaintient également un ordre, mais utilise soit (a) l'ordre «naturel» , c'est-à-dire la valeur de la compareTométhode sur les objets clés définis sur l' Comparableinterface, soit (b) appelle une Comparatorimplémentation que vous fournissez.
  • TreeMapimplémente à la fois l' SortedMapinterface et son successeur, l' NavigableMapinterface.
• NULL s: TreeMapn'autorise pas un NULL comme clé , tandis que HashMap& LinkedHashMapdo.
  • Les trois autorisent NULL comme valeur.
• HashTableest hérité de Java 1 . Supplanté par la ConcurrentHashMapclasse. Citant le Javadoc: ConcurrentHashMapobéit à la même spécification fonctionnelle que Hashtable, et inclut des versions de méthodes correspondant à chaque méthode de Hashtable.

HashMap
peut contenir une clé nulle.

HashMap ne maintient aucune commande.

TreeMap

TreeMap ne peut contenir aucune clé nulle.

TreeMap maintient l'ordre croissant.

LinkedHashMap

LinkedHashMap peut être utilisé pour maintenir l'ordre d'insertion, sur lequel les clés sont insérées dans la carte ou il peut également être utilisé pour maintenir un ordre d'accès, sur lequel les clés sont accessibles.

Exemples ::

1) Carte HashMap = nouveau 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) Carte TreeMap = nouveau 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) Carte LinkedHashMap = nouvelle 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());
    }

Le plus important parmi les trois est de savoir comment ils enregistrent l'ordre des entrées.

HashMap- N'enregistre pas l'ordre des entrées. par exemple.

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: Il enregistre l'ordre dans lequel les entrées ont été effectuées. par exemple:

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: Il enregistre les entrées dans l'ordre croissant des touches. par exemple:

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