Différence entre HashMap, LinkedHashMap et TreeMap

Question

Quelle est la différence entre HashMap, LinkedHashMap et TreeMap en Java? Je ne vois aucune différence dans la sortie car tous les trois ont keySet et values. Que 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());

Answer 1

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

• HashMap ne fait aucune garantie quant à l'ordre des itérations. Il peut (et va) même changer complètement lorsque de nouveaux éléments sont ajoutés.
• TreeMap effectuera une itération en fonction de la "commande naturelle" des touches selon leur méthode compareTo() (ou une méthode Comparator fournie de l'extérieur). 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

"Hashtable" est le nom générique des cartes basées sur le hachage. Dans le contexte de l'API Java, Hashtable est une classe obsolète du temps de Java 1.1 avant l'existence de l'infrastructure de collections. 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 réduire les performances et est généralement inutile). Utilisez ConcurrentHashMap au lieu de Hashtable.

Answer 2

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

Answer 3

Tous les trois représentent un mappage de clés uniques en valeurs et implémentent donc l'interface Map .

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

2. LinkedHashMap est très similaire à HashMap, mais il ajoute une conscience à l'ordre d'ajout (ou d'accès) aux éléments. L'ordre des itérations est donc identique à l'ordre d'insertion (ou à l'ordre d'accès, en fonction des paramètres de construction).

3. TreeMap est un mappage basé sur une arborescence. Ses opérations put/get prennent O (log n) time. Les articles doivent avoir un mécanisme de comparaison, avec Comparable ou Comparator. L'ordre des itérations est déterminé par ce mécanisme.

Answer 4

Voyez où se trouve chaque classe dans la hiérarchie de classes dans le diagramme suivant ( le plus grand ). TreeMap implémente SortedMap et NavigableMap alors que HashMap ne le fait pas.

HashTable est obsolète et la classe ConcurrentHashMap correspondante doit être utilisée. 

Answer 5

HashMap

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

HashTable

• identique à hash map
• il n'autorise pas les clés NULL et les valeurs NULL

LinkedHashMap

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

TreeMap

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

Answer 6

Juste un peu plus de ma propre expérience avec les cartes, quand je les utiliserais:

• HashMap - Le plus utile lorsque vous recherchez une implémentation performante (rapide).
• TreeMap (interface SortedMap) - Très utile lorsque je souhaite pouvoir trier ou parcourir les clés dans un ordre particulier que je définis.
• LinkedHashMap - Combine les avantages de la garantie de commande auprès de TreeMap sans les coûts supplémentaires liés à la maintenance de TreeMap. (Il est presque aussi rapide que le HashMap). LinkedHashMap constitue également un excellent point de départ pour la création d’un objet Cache en remplaçant la méthode removeEldestEntry() . Cela vous permet de créer un objet Cache pouvant expirer des données en utilisant certains critères que vous définissez.

Answer 7

Les trois classes HashMap, TreeMap et LinkedHashMap implémentent l'interface Java.util.Map et représentent le mappage d'une clé unique vers une valeur.

HashMap

1. Un HashMap contient 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 aucune commande .

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

LinkedHashMap

1. Un LinkedHashMap contient 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 en va de même que HashMap conserve à la place l'ordre d'insertion . // Voir décélération de classe ci-dessous

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

TreeMap

1. Un TreeMap contient 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é NULL, mais peut avoir plusieurs valeurs NULL.

4. Il est identique à HashMap à la place, conserve un ordre croissant (trié selon 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 appelée un seau. 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é nulle ni de valeur.
4. Il est synchronisé .

5. C'est une classe d'héritage.

   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

Answer 8

HashMap n'offre aucune garantie quant à l'ordre des itérations. Il peut (et va) même changer complètement lorsque de nouveaux éléments sont ajoutés. TreeMap itérera en fonction de "l'ordre naturel" des clés en fonction de leur méthode compareTo () (ou d'un comparateur fourni en 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 de l'arbre 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

Answer 9

@Amit: SortedMap est une interface alors que TreeMap est une classe qui implémente l'interface SortedMap. Cela signifie que si suit le protocole que SortedMap demande à ses développeurs de faire. Un arbre, à moins d'être implémenté en tant qu'arbre de recherche, ne peut pas vous donner les données commandées, car il peut s'agir de n'importe quel type d'arbre. Ainsi, pour que TreeMap fonctionne comme un ordre trié, il implémente SortedMap (par exemple, arbre de recherche binaire - BST, BST équilibré comme AVL et R-B, voire arbre de recherche ternaire - principalement utilisé pour des recherches itératives de manière ordonnée).

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

Dans NUT-Shell HashMap: donne des données dans O(1), aucun ordre

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

LinkedHashMap: est une table de hachage avec liste (pensez à indexed-SkipList) pour stocker des données de la manière dont elles sont insérées dans l'arborescence. Le mieux adapté pour mettre en œuvre LRU (moins récemment utilisé).

Answer 10

Voici la différence majeure entre HashMap et TreeMap

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

2. Utilisation de l'implémentation HashMap interne Hashing et TreeMap utilisent l'implémentation de l'arborescence rouge-noir.

3. HashMap peut stocker une clé NULL et plusieurs valeurs NULL. TreeMap ne peut pas contenir de clé NULL, mais peut contenir de nombreuses valeurs NULL.

4. HashMap prend des performances constantes dans le temps pour les opérations de base telles que get et put i.e O (1). Conformément aux documents Oracle, TreeMap fournit un coût journalier garanti pour la méthode get et put.

5. HashMap est beaucoup plus rapide que TreeMap, car le temps d'exécution 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.

Answer 11

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

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

Answer 12

• HashMap:

  • Commande non maintenue
  • 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 ceci.

• TreeMap:

  • TreeMap est un mappage basé sur des arbres
  • 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)

Answer 13

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

1  3
5  9
4   6
7   15
3   10

Il peut stocker comme

4  6
5  9
3  10
1  3
7  15

Hashmap lié conserve l'ordre d'insertion.

Exemple.
Si vous insérez des clés

1  3
5  9
4   6
7   15
3   10

Il va stocker comme

1  3
5  9
4   6
7   15
3   10

même que nous insérons.

La carte des arbres 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 va stocker comme

1  3
3  10
4   6
5   9
7   15

Answer 14

Tous offrent une carte clé-> valeur et un moyen de parcourir les clés. La distinction la plus importante entre ces classes concerne les garanties de temps et l’ordre des clés.

1. HashMap offre la recherche et l'insertion 0(1). Si vous parcourez les clés, l'ordre des clés est essentiellement arbitraire. Il est implémenté par un tableau de listes chaînées.
2. TreeMap offre une recherche et une insertion O (log N). Les clés sont ordonnées. Par conséquent, si vous avez besoin de parcourir les clés dans un ordre trié, vous pouvez le faire. 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 en fonction de leur ordre d'insertion. Il est mis en œuvre par des compartiments à double liaison.

Imaginez que vous ayez 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 pour chacun ressemblera aux résultats ci-dessous.

Pour HashMap, le résultat était, dans mes propres tests, {0, 1, -1}, mais il pourrait s'agir de 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}

Answer 15

HashMap
peut contenir une clé nulle.

HashMap ne maintient aucun ordre.

TreeMap

TreeMap ne peut contenir aucune clé NULL.

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 Map, ou il peut également être utilisé pour maintenir un ordre d'accès, sur lequel les clés sont utilisées.

Exemples ::

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