¿Diferencias entre HashMap y Hashtable?

StackOverflow https://stackoverflow.com/questions/40471

Pregunta

¿Cuáles son las diferencias entre un HashMap y un Hashtable en Java?

¿Cuál es más eficiente para aplicaciones sin subprocesos?

¿Fue útil?

Solución

Hay varias diferencias entre HashMap y Hashtable en Java:

  1. Hashtable es sincronizado, mientras HashMap no es.Esto hace HashMap mejor para aplicaciones sin subprocesos, ya que los objetos no sincronizados suelen funcionar mejor que los sincronizados.

  2. Hashtable no permite null claves o valores. HashMap permite uno null clave y cualquier número de null valores.

  3. Una de las subclases de HashMap es LinkedHashMap, por lo que en caso de que desee un orden de iteración predecible (que es el orden de inserción predeterminado), puede cambiar fácilmente el HashMap para LinkedHashMap.Esto no sería tan fácil si estuvieras usando Hashtable.

Dado que la sincronización no es un problema para usted, le recomiendo HashMap.Si la sincronización se convierte en un problema, también puede consultar ConcurrentHashMap.

Otros consejos

Tenga en cuenta que muchas de las respuestas indican que Hashtable está sincronizado. En la práctica, esto te permite comprar muy poco. La sincronización está en los métodos de acceso/mutador y detendrá la adición o eliminación de dos subprocesos del mapa al mismo tiempo, pero en el mundo real a menudo necesitará sincronización adicional.

Un modismo muy común es "verificar y luego poner", es decirbusque una entrada en el Map, y agréguelo si aún no existe.Esta no es de ninguna manera una operación atómica ya sea que use Hashtable o HashMap.

Un sincronizado equivalente HashMap se puede obtener mediante:

Collections.synchronizedMap(myMap);

Pero para implementar correctamente esta lógica es necesario sincronización adicional de la forma:

synchronized(myMap) {
    if (!myMap.containsKey("tomato"))
        myMap.put("tomato", "red");
}

Incluso iterando sobre un Hashtablelas entradas (o un HashMap obtenido por Collections.synchronizedMap) no es seguro para subprocesos a menos que también proteja el Map de ser modificado mediante sincronización adicional.

Implementaciones de la ConcurrentMap interfaz (por ejemplo ConcurrentHashMap) resuelve algo de esto incluyendo Semántica de verificar y luego actuar segura para subprocesos como:

ConcurrentMap.putIfAbsent(key, value);

Hashtable se considera código heredado.No hay nada sobre Hashtable eso no se puede hacer usando HashMap o derivaciones de HashMap, entonces, para el código nuevo, no veo ninguna justificación para volver a Hashtable.

Esta pregunta se hace a menudo en las entrevistas para comprobar si el candidato comprende el uso correcto de las clases de recopilación y conoce las soluciones alternativas disponibles.

  1. La clase HashMap es aproximadamente equivalente a Hashtable, excepto que no está sincronizada y permite valores nulos.(HashMap permite valores nulos como clave y valor, mientras que Hashtable no permite valores nulos).
  2. HashMap no garantiza que el orden del mapa se mantendrá constante en el tiempo.
  3. HashMap no está sincronizado mientras que Hashtable sí está sincronizado.
  4. El iterador en HashMap es a prueba de fallas, mientras que el enumerador de Hashtable no lo es y lanza ConcurrentModificationException si cualquier otro subproceso modifica el mapa estructuralmente agregando o eliminando cualquier elemento excepto el método remove() del propio Iterator.Pero este no es un comportamiento garantizado y JVM lo realizará con el mejor esfuerzo posible.

Nota sobre algunos términos importantes

  1. Sincronizado significa que solo un subproceso puede modificar una tabla hash en un momento determinado.Básicamente, significa que cualquier hilo antes de realizar una actualización en una tabla hash tendrá que adquirir un bloqueo en el objeto mientras que otros esperarán a que se libere el bloqueo.
  2. La seguridad contra fallas es relevante desde el contexto de los iteradores.Si se ha creado un iterador en un objeto de colección y algún otro subproceso intenta modificar el objeto de colección "estructuralmente", se generará una excepción de modificación concurrente.Sin embargo, es posible que otros subprocesos invoquen el método "set" ya que no modifica la colección "estructuralmente".Sin embargo, si antes de llamar a "set", la colección se modificó estructuralmente, se generará "IllegalArgumentException".
  3. Modificación estructural significa eliminar o insertar elementos que podrían cambiar efectivamente la estructura del mapa.

HashMap se puede sincronizar mediante

Map m = Collections.synchronizeMap(hashMap);

MAP proporciona vistas de colección en lugar de soporte directo para la iteración a través de objetos de enumeración.Las vistas de la recolección mejoran enormemente la expresividad de la interfaz, como se discutió más adelante en esta sección.Map le permite iterar sobre claves, valores o pares clave-valor;Hashtable no ofrece la tercera opción.El mapa proporciona una forma segura de eliminar las entradas en medio de la iteración;Hashtable no lo hizo.Finalmente, Map soluciona una deficiencia menor en la interfaz Hashtable.Hashtable tiene un método llamado Contiene, que devuelve verdadero si la hábil contiene un valor dado.Dado su nombre, esperaría que este método devuelva verdadero si la HAESHTABLE contenía una clave dada, porque la clave es el mecanismo de acceso principal para una hashtable.La interfaz MAP elimina esta fuente de confusión cambiando el nombre del método ContinsValue.Además, esto mejora la consistencia de la interfaz: contiene paralelos de valores contenidos.

La interfaz del mapa

HashMap:Una implementación del Map interfaz que utiliza códigos hash para indexar una matriz.Hashtable:Hola, llamado 1998.Quieren recuperar la API de sus colecciones.

En serio, es mejor que te mantengas alejado de Hashtable en total.Para aplicaciones de un solo subproceso, no necesita la sobrecarga adicional de sincronización.Para aplicaciones altamente concurrentes, la sincronización paranoica puede provocar inanición, interbloqueos o pausas innecesarias en la recolección de basura.Como señaló Tim Howland, puedes usar ConcurrentHashMap en cambio.

Manten eso en mente HashTable era una clase heredada antes de que se introdujera Java Collections Framework (JCF) y luego se actualizó para implementar el Map interfaz.Así fue Vector y Stack.

Por lo tanto, manténgase siempre alejado de ellos en el código nuevo, ya que siempre hay una mejor alternativa en el JCF. como otros habían señalado.

Aquí está el Hoja de trucos de la colección Java que te resultará útil.Observe que el bloque gris contiene las clases heredadas HashTable,Vector y Stack.

enter image description here

Además de lo que dijo izb, HashMap permite valores nulos, mientras que el Hashtable no es.

También tenga en cuenta que Hashtable extiende el Dictionary clase, que como Javadocs Estado, está obsoleto y ha sido sustituido por el Map interfaz.

Ya hay muchas buenas respuestas publicadas.Estoy agregando algunos puntos nuevos y resumiéndolos.

HashMap y Hashtable ambos se utilizan para almacenar datos en forma de clave y valor.Ambos utilizan la técnica de hash para almacenar claves únicas.Pero existen muchas diferencias entre las clases HashMap y Hashtable que se detallan a continuación.

HashMap

  1. HashMap no está sincronizado.No es seguro para subprocesos y no se puede compartir entre muchos subprocesos sin el código de sincronización adecuado.
  2. HashMap permite una clave nula y múltiples valores nulos.
  3. HashMap es una nueva clase introducida en JDK 1.2.
  4. HashMap es rápido.
  5. Podemos hacer el HashMap como sincronizado llamando a este código
    Map m = Collections.synchronizedMap(HashMap);
  6. HashMap es atravesado por Iterador.
  7. Iterador en HashMap es infalible.
  8. HashMap hereda la clase AbstractMap.

Tabla de picadillo

  1. Hashtable está sincronizado.Es seguro para subprocesos y se puede compartir con muchos subprocesos.
  2. Hashtable no permite ninguna clave o valor nulo.
  3. Hashtable es una clase heredada.
  4. Hashtable es lento.
  5. Hashtable está sincronizado internamente y no se puede desincronizar.
  6. Hashtable es atravesado por Enumerador e Iterador.
  7. Enumerador en Hashtable no es infalible.
  8. Hashtable hereda la clase Diccionario.

Otras lecturas ¿Cuál es la diferencia entre HashMap y Hashtable en Java?

enter image description here

Echa un vistazo a este gráfico.Proporciona comparaciones entre diferentes estructuras de datos junto con HashMap y Hashtable.La comparación es precisa, clara y fácil de entender.

Matriz de colección de Java

Hashtable es similar al HashMap y tiene una interfaz similar.Se recomienda que utilice HashMap, a menos que necesite soporte para aplicaciones heredadas o necesite sincronización, como Hashtables Los métodos están sincronizados.Entonces, en su caso, como no tiene subprocesos múltiples, HashMaps son tu mejor apuesta.

Otra diferencia clave entre hashtable y hashmap es que Iterator en HashMap es rápido, mientras que el enumerador de Hashtable no lo es y lanza ConcurrentModificationException si cualquier otro Thread modifica el mapa estructuralmente agregando o eliminando cualquier elemento excepto el propio método remove() de Iterator.Pero este no es un comportamiento garantizado y JVM lo realizará con el mejor esfuerzo posible".

Mi fuente: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html

Además de todos los demás aspectos importantes ya mencionados aquí, la API de colecciones (p. ej.Map interface) se modifica todo el tiempo para ajustarse a las "últimas y mejores" incorporaciones a las especificaciones de Java.

Por ejemplo, compare la iteración del mapa de Java 5:

for (Elem elem : map.keys()) {
  elem.doSth();
}

versus el antiguo enfoque de Hashtable:

for (Enumeration en = htable.keys(); en.hasMoreElements(); ) {
  Elem elem = (Elem) en.nextElement();
  elem.doSth();
}

En Java 1.8 también se nos promete poder construir y acceder a HashMaps como en los viejos lenguajes de scripting:

Map<String,Integer> map = { "orange" : 12, "apples" : 15 };
map["apples"];

Actualizar: No, no aterrizarán en 1.8...:(

¿Las mejoras en la colección de Project Coin estarán en JDK8?

  • Tabla de picadillo está sincronizado, si lo estás usando en un solo hilo puedes usar HashMap, que es una versión no sincronizada.Los objetos no sincronizados suelen tener un poco más de rendimiento.Por cierto, si varios subprocesos acceden a un HashMap al mismo tiempo y al menos uno de los subprocesos modifica el mapa estructuralmente, debe sincronizarse externamente.Puede envolver un mapa no sincronizado en uno sincronizado usando:

    Map m = Collections.synchronizedMap(new HashMap(...));

  • HashTable solo puede contener un objeto no nulo como clave o valor.HashMap puede contener una clave nula y valores nulos.

  • Los iteradores devueltos por Map son a prueba de fallos. Si el mapa se modifica estructuralmente en cualquier momento después de crear el iterador, de cualquier manera, excepto a través del método de eliminación del propio iterador, el iterador arrojará un ConcurrentModificationException.Por lo tanto, ante una modificación concurrente, el iterador falla rápida y claramente, en lugar de correr el riesgo de comportarse arbitrariamente y no determinista en un momento indeterminado en el futuro. Mientras Las enumeraciones devueltas por los métodos de claves y elementos de Hashtable no son rápidas.

  • HashTable y HashMap son miembros de la Marco de colecciones de Java (desde la plataforma Java 2 v1.2, HashTable se actualizó para implementar la interfaz Map).

  • HashTable se considera código heredado, la documentación recomienda su uso Mapa de hash concurrente en lugar de Hashtable si se desea una implementación altamente concurrente segura para subprocesos.

  • HashMap no garantiza el orden en el que se devuelven los elementos.Para HashTable, supongo que es lo mismo, pero no estoy del todo seguro, no encuentro recursos que lo indiquen claramente.

HashMap y Hashtable También tienen diferencias algorítmicas significativas.Nadie ha mencionado esto antes, por eso lo menciono. HashMap construirá una tabla hash con una potencia de dos tamaños, la aumentará dinámicamente de modo que tenga como máximo unos ocho elementos (colisiones) en cualquier depósito y agitará muy bien los elementos para los tipos de elementos generales.sin embargo, el Hashtable La implementación proporciona un control mejor y más preciso sobre el hash si sabe lo que está haciendo, es decir, puede corregir el tamaño de la tabla usando, por ejemplo.el número primo más cercano al tamaño de su dominio de valores y esto dará como resultado un mejor rendimiento que HashMap, es decir,Menos colisiones en algunos casos.

Aparte de las diferencias obvias que se analizan ampliamente en esta pregunta, veo Hashtable como un automóvil de "conducción manual" donde se tiene un mejor control sobre el hash y el HashMap como la contraparte de "conducción automática" que generalmente funcionará bien.

Hashtable está sincronizado, mientras que HashMap no.Eso hace que Hashtable sea más lento que Hashmap.

Para aplicaciones sin subprocesos, utilice HashMap ya que, por lo demás, son iguales en términos de funcionalidad.

Basado en la información aquí, Recomendaría utilizar HashMap.Creo que la mayor ventaja es que Java evitará que lo modifiques mientras lo iteras, a menos que lo hagas a través del iterador.

A Collection (a veces llamado contenedor) es simplemente un objeto que agrupa varios elementos en una sola unidad. CollectionLos s se utilizan para almacenar, recuperar, manipular y comunicar datos agregados.Un marco de colecciones W. es una arquitectura unificada para representar y manipular colecciones.

El HashMap JDK1.2 y tabla hash JDK1.0, ambos se utilizan para representar un grupo de objetos que se representan en <Key, Value> par.Cada <Key, Value> par se llama Entry objeto.La colección de Inscripciones está referida por el objeto de HashMap y Hashtable.Las claves de una colección deben ser únicas o distintivas.[ya que se utilizan para recuperar un valor asignado a una clave particular.los valores de una colección se pueden duplicar.]

« Miembro de Superclase, Legacy y Collection Framework

Hashtable es una clase heredada introducida en JDK1.0, que es una subclase de la clase Diccionario.De JDK1.2 Hashtable está rediseñado para implementar la Interfaz de mapa para convertirse en miembro del marco de recopilación.HashMap es miembro de Java Collection Framework desde el comienzo de su introducción en JDK1.2.HashMap es la subclase de la clase AbstractMap.

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

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

« Capacidad inicial y factor de carga

La capacidad es la cantidad de depósitos en la tabla hash y la capacidad inicial es simplemente la capacidad en el momento en que se crea la tabla hash.Tenga en cuenta que la tabla hash está abierta:en el caso de un "hashcollision", un único depósito almacena varias entradas, que deben buscarse secuencialmente.El factor de carga es una medida de qué tan llena se permite que esté la tabla hash antes de que su capacidad aumente automáticamente.

HashMap construye una tabla hash vacía con la capacidad inicial predeterminada (16) y el factor de carga predeterminado (0,75).Mientras que Hashtable construye una tabla hash vacía con una capacidad inicial predeterminada (11) y factor de carga/relación de llenado (0,75).

Hash Map & Hashtable

« Modificación estructural en caso de colisión de hash.

HashMap, Hashtable en caso de colisiones de hash, almacenan las entradas del mapa en listas vinculadas. De Java8 para HashMap Si el depósito de hash crece más allá de un cierto umbral, ese depósito cambiará de linked list of entries to a balanced tree.que mejoran el rendimiento en el peor de los casos de O (n) a O (log n).Al convertir la lista a un árbol binario, el código hash se utiliza como variable de ramificación.Si hay dos códigos hash diferentes en el mismo depósito, uno se considera más grande y va a la derecha del árbol y el otro a la izquierda.Pero cuando ambos códigos hash son iguales, HashMap asume que las claves son comparables y compara la clave para determinar la dirección de modo que se pueda mantener cierto orden.Es una buena práctica hacer las llaves de HashMap comparable.Al agregar entradas si el tamaño del depósito alcanza TREEIFY_THRESHOLD = 8 convertir la lista vinculada de entradas en un árbol equilibrado, al eliminar entradas de menos de TREEIFY_THRESHOLD y como mucho UNTREEIFY_THRESHOLD = 6 reconvertirá el árbol equilibrado en una lista vinculada de entradas. Java 8 SRC, poste de pila

« Iteración de vista de colección, a prueba de fallos y a prueba de fallos

    +--------------------+-----------+-------------+
    |                    | Iterator  | Enumeration |
    +--------------------+-----------+-------------+
    | Hashtable          | fail-fast |    safe     |
    +--------------------+-----------+-------------+
    | HashMap            | fail-fast | fail-fast   |
    +--------------------+-----------+-------------+
    | ConcurrentHashMap  |   safe    |   safe      |
    +--------------------+-----------+-------------+

Iterator es un fracaso por naturaleza.es decir, arroja una excepción ConcurrentModificationException si se modifica una colección mientras se itera un método distinto al suyo remove().Mientras Enumeration es de naturaleza a prueba de fallos.No genera ninguna excepción si una colección se modifica durante la iteración.

Según Java API Docs, siempre se prefiere Iterador a Enumeración.

NOTA: La funcionalidad de la interfaz Enumeration está duplicada por la interfaz Iterator.Además, Iterator agrega una operación de eliminación opcional y tiene nombres de método más cortos.Las nuevas implementaciones deberían considerar el uso de Iterator en lugar de Enumeration.

En Java 5 introdujo la interfaz ConcurrentMap: ConcurrentHashMap - un sistema altamente concurrente y de alto rendimiento ConcurrentMap implementación respaldada por una tabla hash.Esta implementación nunca se bloquea al realizar recuperaciones y permite al cliente seleccionar el nivel de simultaneidad para las actualizaciones.Está pensado como un reemplazo directo para Hashtable:además de implementar ConcurrentMap, admite todos los métodos "heredados" propios de Hashtable.

  • Cada HashMapEntryel valor es volátil asegurando así una consistencia fina para modificaciones contenidas y lecturas posteriores;cada lectura refleja la actualización completa más reciente

  • Los iteradores y las enumeraciones son a prueba de fallos: reflejan el estado en algún momento desde la creación del iterador/enumeración;esto permite lecturas y modificaciones simultáneas a costa de una menor coherencia.No lanzan ConcurrentModificationException.Sin embargo, los iteradores están diseñados para ser utilizados por un solo subproceso a la vez.

  • Como Hashtable pero a diferencia HashMap, esta clase no permite que se utilice nulo como clave o valor.

public static void main(String[] args) {

    //HashMap<String, Integer> hash = new HashMap<String, Integer>();
    Hashtable<String, Integer> hash = new Hashtable<String, Integer>();
    //ConcurrentHashMap<String, Integer> hash = new ConcurrentHashMap<>();

    new Thread() {
        @Override public void run() {
            try {
                for (int i = 10; i < 20; i++) {
                    sleepThread(1);
                    System.out.println("T1 :- Key"+i);
                    hash.put("Key"+i, i);
                }
                System.out.println( System.identityHashCode( hash ) );
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();
    new Thread() {
        @Override public void run() {
            try {
                sleepThread(5);
                // ConcurrentHashMap  traverse using Iterator, Enumeration is Fail-Safe.

                // Hashtable traverse using Enumeration is Fail-Safe, Iterator is Fail-Fast.
                for (Enumeration<String> e = hash.keys(); e.hasMoreElements(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ e.nextElement());
                }

                // HashMap traverse using Iterator, Enumeration is Fail-Fast.
                /*
                for (Iterator< Entry<String, Integer> > it = hash.entrySet().iterator(); it.hasNext(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ it.next());
                    // ConcurrentModificationException at java.util.Hashtable$Enumerator.next
                }
                */

                /*
                Set< Entry<String, Integer> > entrySet = hash.entrySet();
                Iterator< Entry<String, Integer> > it = entrySet.iterator();
                Enumeration<Entry<String, Integer>> entryEnumeration = Collections.enumeration( entrySet );
                while( entryEnumeration.hasMoreElements() ) {
                    sleepThread(1);
                    Entry<String, Integer> nextElement = entryEnumeration.nextElement();
                    System.out.println("T2 : "+ nextElement.getKey() +" : "+ nextElement.getValue() );
                    //java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode
                    //                                          at java.util.HashMap$EntryIterator.next
                    //                                          at java.util.Collections$3.nextElement
                }
                */
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();

    Map<String, String> unmodifiableMap = Collections.unmodifiableMap( map );
    try {
        unmodifiableMap.put("key4", "unmodifiableMap");
    } catch (java.lang.UnsupportedOperationException e) {
        System.err.println("UnsupportedOperationException : "+ e.getMessage() );
    }
}
static void sleepThread( int sec ) {
    try {
        Thread.sleep( 1000 * sec );
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

« Claves nulas y valores nulos

HashMap permite como máximo una clave nula y cualquier número de valores nulos.Mientras Hashtable no permite ni siquiera una sola clave nula y un valor nulo, si la clave o el valor es nulo, arroja NullPointerException. Ejemplo

« Sincronizado, seguro para subprocesos

Hashtable está sincronizado internamente.Por lo tanto, es muy seguro de usar. Hashtable en aplicaciones multiproceso.Mientras HashMap no está sincronizado internamente.Por lo tanto, no es seguro utilizarlo. HashMap en aplicaciones multiproceso sin sincronización externa.Puedes sincronizar externamente HashMap usando Collections.synchronizedMap() método.

« Actuación

Como Hashtable está sincronizado internamente, esto hace Hashtable ligeramente más lento que el HashMap.

@Ver

Para aplicaciones con subprocesos, a menudo puede salirse con la suya con ConcurrentHashMap; depende de sus requisitos de rendimiento.

1.Hashmap y HashTable tanto la clave de la tienda como el valor.

2.Hashmap puede almacenar una clave como null. Hashtable no puedo almacenar null.

3.HashMap no está sincronizado pero Hashtable está sincronizado.

4.HashMap se puede sincronizar con Collection.SyncronizedMap(map)

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);

Aparte de las diferencias ya mencionadas, cabe señalar que desde Java 8, HashMap reemplaza dinámicamente los Nodos (lista vinculada) utilizados en cada depósito con TreeNodes (árbol rojo-negro), de modo que incluso si existen altas colisiones de hash, el peor de los casos al buscar es

O(log(n)) para HashMap contra O(n) en Hashtable.

*La mejora antes mencionada no se ha aplicado a Hashtable todavía, pero sólo para HashMap, LinkedHashMap, y ConcurrentHashMap.

Para su información, actualmente,

  • TREEIFY_THRESHOLD = 8 :Si un depósito contiene más de 8 nodos, la lista vinculada se transforma en un árbol equilibrado.
  • UNTREEIFY_THRESHOLD = 6 :cuando un depósito se vuelve demasiado pequeño (debido a su eliminación o cambio de tamaño), el árbol se vuelve a convertir en una lista vinculada.

Existen 5 diferenciaciones básicas con HashTable y HashMaps.

  1. Maps le permite iterar y recuperar claves, valores y también ambos pares clave-valor, mientras que HashTable no tiene toda esta capacidad.
  2. En Hashtable hay una función contiene (), que es muy confusa de usar.Porque el significado de contiene difiere ligeramente.¿Si significa contiene clave o contiene valor?difícil de entender.Lo mismo en Maps tenemos las funciones ContieneKey() y ContieneValue(), que son muy fáciles de entender.
  3. En hashmap puedes eliminar elementos mientras iteras, de forma segura.donde no es posible en las tablas hash.
  4. Las HashTables están sincronizadas de forma predeterminada, por lo que se pueden usar con múltiples subprocesos fácilmente.Mientras que los HashMaps no están sincronizados de forma predeterminada, se pueden usar con un solo subproceso.Pero aún puede convertir HashMap a sincronizado utilizando la función sincronizadaMap(Map m) de la clase de utilidad Colecciones.
  5. HashTable no permitirá claves nulas ni valores nulos.Mientras que HashMap permite una clave nula y múltiples valores nulos.

Mi pequeño aporte:

  1. La primera y más significativa diferencia entre Hashtable y HashMap es eso, HashMap no es seguro para subprocesos mientras Hashtable es una colección segura para subprocesos.

  2. Segunda diferencia importante entre Hashtable y HashMap es el rendimiento, ya que HashMap no está sincronizado, funciona mejor que Hashtable.

  3. Tercera diferencia en Hashtable vs HashMap es eso Hashtable es una clase obsoleta y deberías usarla ConcurrentHashMap en lugar de Hashtable en Java.

Tabla de picadillo es una clase heredada en el jdk que ya no debería usarse.Reemplace sus usos con Mapa de hash concurrente.Si no necesita seguridad para hilos, use HashMap cual no es a salvo de amenazas pero más rápido y usa menos memoria.

1) Hashtable está sincronizado mientras que hashmap no.2) Otra diferencia es que el iterador en HashMap es a prueba de fallas, mientras que el enumerador de Hashtable no lo es.Si cambia el mapa mientras itera, lo sabrá.

3) HashMap permite valores nulos, mientras que Hashtable no.

HashMap y HashTable

  • Algunos puntos importantes sobre HashMap y HashTable.lea los detalles a continuación.

1) Hashtable y HashMap implementan la interfaz Java.util.Map 2) tanto hashmap como hashtable es la colección basada en hash.y trabajando en hash.entonces estas son similitudes de HashMap y HashTable.

  • ¿Cuál es la diferencia entre HashMap y HashTable?

1) La primera diferencia es que HashMap no es seguro para subprocesos, mientras que HashTable es ThreadSafe
2) HashMap mejora el rendimiento porque no es seguro para subprocesos.mientras que el rendimiento de Hashtable no es mejor porque es seguro para subprocesos.por lo que varios subprocesos no pueden acceder a Hashtable al mismo tiempo.

Mapa Hash:Es una clase disponible dentro del paquete java.util y se utiliza para almacenar el elemento en formato de clave y valor.

Tabla de picadillo:Es una clase heredada que se reconoce dentro del marco de la colección.

Hashtable:

Tabla de picadillo es una estructura de datos que conserva los valores del par clave-valor.No permite valores nulos tanto para las claves como para los valores.Obtendrás un NullPointerException si agrega valor nulo.Está sincronizado.Entonces viene con su costo.Sólo un hilo puede acceder Tabla de picadillo en un momento determinado.

Ejemplo :

import java.util.Map;
import java.util.Hashtable;

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states= new Hashtable<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    //will throw NullPointerEcxeption at runtime

    System.out.println(states.get(1));
    System.out.println(states.get(2));
//  System.out.println(states.get(3));

    }
}

Mapa Hash:

HashMap es como Tabla de picadillo pero también acepta pares clave-valor.Permite nulos tanto para las claves como para los valores.Su rendimiento es mejor que HashTable, porque es unsynchronized.

Ejemplo:

import java.util.HashMap;
import java.util.Map;

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states = new HashMap<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    // Okay
    states.put(null,"UK");

    System.out.println(states.get(1));
    System.out.println(states.get(2));
    System.out.println(states.get(3));

    }
}

HashMaps te brinda libertad de sincronización y la depuración es mucho más fácil

HashMap es emulado y por lo tanto utilizable en GWT client code mientras Hashtable no es.

Sincronización o seguridad para subprocesos :

Hash Map no está sincronizado, por lo tanto, no es seguro para subprocesos y no se puede compartir entre varios subprocesos sin el bloque sincronizado adecuado, mientras que Hashtable está sincronizado y, por lo tanto, es seguro para subprocesos.

Claves nulas y valores nulos :

HashMap permite una clave nula y cualquier número de valores nulos. Hashtable no permite claves o valores nulos.

Iterando los valores:

El iterador en HashMap es un iterador a prueba de fallas, mientras que el enumerador de Hashtable no lo es y lanza ConcurrentModificationException si cualquier otro subproceso modifica el mapa estructuralmente agregando o eliminando cualquier elemento excepto el método remove() del propio Iterator.

Superclase y legado :

HashMap es una subclase de la clase AbstractMap, mientras que Hashtable es una subclase de la clase Diccionario.

Actuación :

Como HashMap no está sincronizado, es más rápido en comparación con Hashtable.

Referirse http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java para ejemplos, preguntas de entrevistas y cuestionarios relacionados con la colección Java

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top