avantage - linkedhashmap java




Différence entre HashMap, LinkedHashMap et TreeMap (10)

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 clés en fonction de 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 va itérer dans l'ordre dans lequel les entrées ont été placées dans la carte

Regardez comment la performance varie ..

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

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 . Quels sont les Hashtable s?

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

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

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 vice versa.

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


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

La carte de hachage ne préserve 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 comme

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 va le stocker comme

1  3
5  9
4   6
7   15
3   10

même que nous insérons.

La carte d'arbre stocke les vales dans l'ordre croissant des clefs. Exemple.
Si vous insérez des clés

1  3
5  9
4   6
7   15
3   10

Il va le stocker comme

1  3
3  10
4   6
5   9
7   15

Les trois classes HashMap , TreeMap et LinkedHashMap implémentent l'interface java.util.Map et représentent le mappage de la clé unique aux valeurs.

HashMap

  1. Un 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 ne maintient aucun ordre .

    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 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 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. 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 la même chose que HashMap maintient l' ordre ascendant (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


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 trié 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.

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

  1. HashMap est une carte basée sur le hashing des clés. Il supporte O (1) opérations get / put. Les clés doivent avoir des 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.


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 qu'en tant que TreeSet, les éléments TreeMap sont également triés en fonction de l'ordre naturel de ses éléments.

  2. Implémentation de l'implémentation HashMap interne Hashing et TreeMap utilisent en interne l'implémentation de l'arborescence Red-Black.

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

  4. HashMap prend des performances à temps constant pour les opérations de base comme get et put, c'est-à-dire O (1). Selon les documents Oracle, TreeMap fournit un coût de temps de 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 TreeMap du temps du journal 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.


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 la classe ConcurrentHashMap correspondante doit être utilisée.





map