Question Différence entre HashMap, LinkedHashMap et TreeMap


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 a keySet et 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());

816
2018-05-22 21:10


origine


Réponses:


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

  • HashMap ne donne absolument aucune garantie quant à l'ordre d'itération. Il peut (et va) même changer complètement lorsque de nouveaux éléments sont ajoutés.
  • TreeMap va itérer selon "l'ordre naturel" des clés en fonction de leur compareTo() méthode (ou un externe fourni Comparator). De plus, il met en œuvre SortedMap interface, 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 sur la carte

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


1019
2018-05-22 21:18



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

1383
2017-07-17 19:24



Tous les trois représentent le mappage des clés uniques aux valeurs, et donc mettre en œuvre le Carte interface.

  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 sensibilité à l'ordre dans lequel 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 ordre d'accès, selon les paramètres de construction).

  3. TreeMap est un mappage basé sur l'arbre. Ses opérations put / get prennent le temps O (log n). Il nécessite des éléments pour avoir un mécanisme de comparaison, soit avec Comparable ou Comparator. L'ordre d'itération est déterminé par ce mécanisme.


60
2018-05-22 21:17



Voir où chaque classe est dans la hiérarchie des classes dans le diagramme suivant (plus grand). TreeMap implémente SortedMap et NavigableMap tandis que HashMap ne le fait pas.

HashTable est obsolète et le correspondant ConcurrentHashMap classe devrait être utilisé. enter image description here


37
2018-01-30 02:28



Juste un peu plus de contribution de ma propre expérience avec des cartes, sur quand je voudrais utiliser chacun d'eux:

  • HashMap - Plus utile lorsque vous recherchez une implémentation (rapide) de meilleure performance.
  • TreeMap (Interface SortedMap) - Plus utile lorsque je suis capable de trier ou d'itérer sur les touches dans un ordre particulier que je définis.
  • LinkedHashMap - Combine les avantages de la commande garantie de TreeMap sans le coût accru de la maintenance de TreeMap. (Il est presque aussi rapide que le HashMap). En particulier, le LinkedHashMap fournit également un excellent point de départ pour créer un objet Cache en remplaçant le removeEldestEntry()méthode. Cela vous permet de créer un objet Cache pouvant expirer des données en utilisant certains critères que vous définissez.

35
2017-08-27 18:51



HashMap

  • Il a des valeurs de paires (clés, valeurs)
  • Aucune valeur de clé de duplication
  • non trié non trié
  • il permet une clé nulle et plus d'une valeur nulle

HashTable

  • même que 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 ordonnée et triée
  • basé sur des structures de données de hachage

34
2017-10-18 04:55



Les trois classes HashMap, TreeMap et LinkedHashMap met en oeuvre java.util.Map interface, et représente le mappage de la clé unique aux valeurs.

HashMap

  1. UNE HashMap contient des valeurs basées sur la clé.

  2. Il contient uniquement des éléments uniques.

  3. Il peut avoir une clé nulle et plusieurs valeurs nulles.

  4. Il maintient pas de commande.

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

LinkedHashMap

  1. UNE LinkedHashMap contient des valeurs basées sur la clé.
  2. Il contient uniquement des éléments uniques.
  3. Il peut avoir une clé nulle et plusieurs valeurs nulles.
  4. C'est la même chose que HashMap maintient à la place 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. UNE TreeMap contient des valeurs basées sur la clé. Il implémente l'interface NavigableMap et étend la classe AbstractMap.
  2. Il contient uniquement des éléments uniques.
  3. Il ne peut pas avoir de clé nulle mais peut avoir plusieurs valeurs nulles.
  4. C'est pareil que HashMap maintient plutôt 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. Un Hashtable est un tableau de liste. Chaque liste est connue comme 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 contient uniquement des éléments uniques.
  3. Il peut n'avoir aucune clé ou valeur nulle.
  4. C'est synchronisé.
  5. C'est un cours d'héritage.

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

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


15
2018-05-05 05:28



HashMap ne donne absolument aucune garantie sur l'ordre d'itération. Il   peut (et va) même changer complètement lorsque de nouveaux éléments sont ajoutés.   TreeMap va itérer selon "l'ordre naturel" des touches   selon leur méthode compareTo () (ou une alimentation externe   Comparateur). En outre, il implémente l'interface SortedMap,   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 sur la carte

Regardez comment la performance varie .. enter image description here

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


14
2017-07-17 17:29



Permettez-moi de dire simplement:

  • HashMap est implémenté comme une table de hachage, et il n'y a pas d'ordre sur les clés ou les valeurs.
  • TreeMap est implémenté basé sur la structure arborescente rouge-noire, et il est ordonné par la clé.
  • LinkedHashMap préserve l'ordre d'insertion
  • Hashtable est synchronisé, contrairement à HashMap. Il a une surcharge pour la synchronisation. C'est la raison pour laquelle HashMap devrait être utilisé si le programme est thread-safe.

10
2018-06-17 11:19