qué - treemap java




Diferencia entre HashMap, LinkedHashMap y TreeMap (10)

¿Cuál es la diferencia entre HashMap , LinkedHashMap y TreeMap en Java? No veo ninguna diferencia en la salida ya que los tres tienen values y values keySet . ¿Qué son los 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 no ofrece ninguna garantía sobre el orden de iteración. Puede (y lo hará) incluso cambiar completamente cuando se agreguen nuevos elementos. TreeMap se repetirá de acuerdo con el "orden natural" de las teclas según su método compareTo () (o un Comparador suministrado externamente). Además, implementa la interfaz SortedMap, que contiene métodos que dependen de este orden de clasificación. LinkedHashMap se repetirá en el orden en que se colocaron las entradas en el mapa.

Mira cómo varía el rendimiento ...

Mapa del árbol que es una implementación del mapa ordenado. La complejidad de la operación de poner, obtener y contiene la clave es O (log n) debido al orden natural


HashMap

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

Tabla de picadillo

  • igual que el mapa hash
  • No permite claves nulas ni valores nulos.

LinkedHashMap

  • Se ordena la versión de la implementación del mapa.
  • Basado en listas enlazadas y estructuras de datos hash

TreeMap

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

El mapa hash no conserva el orden de inserción.
Ejemplo. Hashmap Si está insertando claves como

1  3
5  9
4   6
7   15
3   10

Se puede almacenar como

4  6
5  9
3  10
1  3
7  15

El Hashmap vinculado conserva el orden de inserción.

Ejemplo.
Si estas insertando llaves

1  3
5  9
4   6
7   15
3   10

Lo almacenará como

1  3
5  9
4   6
7   15
3   10

Igual que insertamos.

El mapa del árbol almacena los vales en orden creciente de llaves. Ejemplo.
Si estas insertando llaves

1  3
5  9
4   6
7   15
3   10

Lo almacenará como

1  3
3  10
4   6
5   9
7   15

Estas son diferentes implementaciones de la misma interfaz. Cada implementación tiene algunas ventajas y algunas desventajas (inserción rápida, búsqueda lenta) o viceversa.

Para obtener más información, consulte el javadoc de TreeMap , HashMap , LinkedHashMap .


Las tres clases HashMap , TreeMap y LinkedHashMap implementan la interfaz java.util.Map , y representan la asignación de una clave única a los valores.

HashMap

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

  2. Sólo contiene elementos únicos.

  3. Puede tener una clave nula y varios valores nulos.

  4. No mantiene ningún 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. Sólo contiene elementos únicos.
  3. Puede tener una clave nula y varios valores nulos.
  4. Es igual que HashMap en cambio mantiene el orden de inserción . // Ver la 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 extiende la clase AbstractMap.
  2. Sólo contiene elementos únicos.
  3. No puede tener una clave nula, pero puede tener varios valores nulos.
  4. Es igual que HashMap cambio, mantiene un orden ascendente ( ordenado según el orden natural de su clave).

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

Hashtable

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

    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


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

  • HashMap ofrece ninguna garantía sobre el orden de iteración. Puede (y lo hará) incluso cambiar completamente cuando se agreguen nuevos elementos.
  • TreeMap se TreeMap acuerdo con el "orden natural" de las teclas según su compareTo() (o un Comparator suministrado externamente). Además, implementa la interfaz SortedMap , que contiene métodos que dependen de este orden de clasificación.
  • LinkedHashMap repetirá en el orden en que se colocaron las entradas en el mapa.

"Hashtable" es el nombre genérico para 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 las colecciones. Ya no debe usarse, ya que su API está llena de métodos obsoletos que duplican la funcionalidad y sus métodos están sincronizados (lo que puede disminuir el rendimiento y generalmente es inútil). Utilice ConcurrentHashMap lugar de Hashtable.


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

Solo algunos comentarios más de mi propia experiencia con 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): es muy útil cuando me preocupa poder ordenar o iterar las teclas en un orden particular que defino.
  • LinkedHashMap: combina las ventajas de los pedidos garantizados de TreeMap sin el mayor costo de mantener el TreeMap. (Es casi tan rápido como el HashMap). En particular, LinkedHashMap también proporciona un excelente punto de partida para crear un objeto Cache al reemplazar el método removeEldestEntry() . Esto le permite crear un objeto de caché que puede caducar los datos usando algunos criterios que usted define.

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

HashTable está obsoleto y se debe usar la clase ConcurrentHashMap correspondiente.


HashMap
Puede contener una clave nula.

HashMap no mantiene orden.

TreeMap

TreeMap no puede contener ninguna clave nula.

TreeMap mantiene un orden ascendente.

LinkedHashMap

LinkedHashMap se puede utilizar para mantener el orden de inserción, en el que se insertan las claves en el Mapa o también se puede usar para mantener un orden de acceso, en el que se accede a las claves.

Ejemplos ::

1) mapa HashMap = nuevo 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) Mapa TreeMap = nuevo 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) Mapa 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());
    }






map