Pregunta Diferencia entre HashMap, LinkedHashMap y TreeMap


Cuál es la diferencia entre HashMap, LinkedHashMap y TreeMap en Java? No veo ninguna diferencia en el resultado ya que los tres tienen keySet y values. Qué son 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


origen


Respuestas:


Las tres clases implementan el Map interfaz y ofrecen principalmente la misma funcionalidad. La diferencia más importante es el orden en que se realizará la iteración a través de las entradas:

  • HashMap no ofrece absolutamente ninguna garantía sobre el orden de iteración. Puede (e incluso) cambiará completamente cuando se agreguen nuevos elementos.
  • TreeMap iterará de acuerdo con el "orden natural" de las teclas de acuerdo a su compareTo() método (o un suministro externo Comparator) Además, implementa el SortedMap interfaz, que contiene métodos que dependen de este orden de clasificación.
  • LinkedHashMap iterará en el orden en que se colocaron las entradas en el mapa

"Tabla de picadillo" es el nombre genérico de los mapas basados ​​en hash. En el contexto de la API de Java, Hashtable es una clase obsoleta desde los días de Java 1.1 antes de que existiera el marco de colecciones. Ya no debería usarse, porque su API está atestada de métodos obsoletos que duplican la funcionalidad, y sus métodos están sincronizados (lo que puede disminuir el rendimiento y, en general, es inútil). Utilizar ConcurrentHashMap en lugar de Hashtable


1019
2018-05-22 21:18



Prefiero la presentación visual:

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



Los tres representan mapeo de claves únicas a valores, y por lo tanto implementan el Mapa interfaz.

  1. HashMap es un mapa basado en hash de las llaves Admite O (1) operaciones get / put. Las llaves deben tener implementaciones consistentes de hashCode() y equals() para que esto funcione

  2. LinkedHashMap es muy similar a HashMap, pero agrega conocimiento al orden en el que se agregan (o acceden), por lo que el orden de iteración es el mismo que el orden de inserción (o el orden de acceso, dependiendo de los parámetros de construcción).

  3. TreeMap es un mapeo basado en árbol. Sus operaciones put / get toman el tiempo O (log n). Requiere elementos para tener algún mecanismo de comparación, ya sea con Comparable o Comparador. El orden de iteración está determinado por este mecanismo.


60
2018-05-22 21:17



Vea dónde está cada clase en la jerarquía de clases en el siguiente diagrama (uno más grande) Implementos TreeMap SortedMap y NavigableMap mientras HashMap no.

HashTable es obsoleto y el correspondiente ConcurrentHashMap clase debe ser utilizada. enter image description here


37
2018-01-30 02:28



Solo algunos comentarios más de mi propia experiencia con los mapas, sobre cuándo usaría cada uno:

  • HashMap: más útil cuando se busca una implementación de mejor rendimiento (rápida).
  • TreeMap (interfaz SortedMap): más útil cuando estoy preocupado por poder ordenar o iterar sobre las teclas en un orden particular que defino.
  • LinkedHashMap: combina las ventajas del pedido garantizado de TreeMap sin el mayor costo de mantener TreeMap. (Es casi tan rápido como HashMap). En particular, LinkedHashMap también proporciona un excelente punto de partida para crear un objeto Cache al anular el removeEldestEntry()método. Esto le permite crear un objeto de caché que puede caducar datos utilizando algunos criterios que defina.

35
2017-08-27 18:51



HashMap

  • Tiene valores de par (claves, valores)
  • NO valores clave de duplicación
  • desordenado sin ordenar
  • permite una clave nula y más de un valor nulo

Tabla de picadillo

  • lo mismo que el hash map
  • no permite claves nulas y valores nulos

LinkedHashMap

  • Es la versión ordenada de la implementación del mapa
  • Basado en listas enlazadas y estructuras de datos hash

TreeMap

  • Versión pedida y clasificada
  • basado en estructuras de datos hash

34
2017-10-18 04:55



Las tres clases HashMap, TreeMap y LinkedHashMap implementos java.util.Map interfaz, y representa la asignación de clave única a valores.

HashMap

  1. UN HashMap contiene valores basados ​​en la clave.

  2. Contiene solo elementos únicos.

  3. Puede tener una clave nula y múltiples valores nulos.

  4. Mantiene sin orden.

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

LinkedHashMap

  1. UN LinkedHashMap contiene valores basados ​​en la clave.
  2. Contiene solo elementos únicos.
  3. Puede tener una clave nula y múltiples valores nulos.
  4. Es lo mismo que HashMap en cambio mantiene orden de insercion. // Ver desaceleración de clase a continuación

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

TreeMap

  1. UN TreeMap contiene valores basados ​​en la clave. Implementa la interfaz NavigableMap y amplía la clase AbstractMap.
  2. Contiene solo elementos únicos.
  3. No puede tener una clave nula, pero puede tener múltiples valores nulos.
  4. Es lo mismo que HashMap en cambio mantiene orden ascendente(Ordenado usando el orden natural de su clave).

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

Tabla de picadillo

  1. Un Hashtable es una matriz de lista. Cada lista se conoce como un cubo. La posición de la cuchara se identifica llamando al método hashcode (). Un Hashtable contiene valores basados ​​en la clave.
  2. Contiene solo elementos únicos.
  3. Es posible que no tenga ninguna clave o valor nulo.
  4. Es sincronizado.
  5. Es una clase heredada.

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

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


15
2018-05-05 05:28



HashMap no garantiza en absoluto el orden de iteración. Eso   puede (y lo hará) incluso cambiar completamente cuando se agregan nuevos elementos.   TreeMap iterará de acuerdo con el "orden natural" de las claves   según su método compareTo () (o un método externo)   Comparador). Además, implementa la interfaz SortedMap,   que contiene métodos que dependen de este orden de clasificación. LinkedHashMap   iterará en el orden en que se colocaron las entradas en el mapa

Mira cómo varía el rendimiento ... enter image description here

Mapa de árbol que es una implementación del mapa ordenado. La complejidad de las operaciones put, get y containsKey es O (log n) debido a la ordenación Natural


14
2017-07-17 17:29