objetos metodos instead con java collections hashmap hashtable

java - metodos - Diferencias entre HashMap y Hashtable?



map y hashmap java (30)

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

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

1. Hashmap y HashTable almacenan clave y valor.

2. Hashmap puede almacenar una clave como null . Hashtable no puede 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);

Además de las diferencias ya mencionadas, se debe tener en cuenta que, dado que Java 8, HashMap reemplaza dinámicamente los Nodos (lista enlazada) utilizados en cada grupo con TreeNodes (árbol rojo-negro), de modo que incluso si existen colisiones de hash altas, el peor caso cuando la búsqueda es

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

* La mejora antes mencionada aún no se ha aplicado a Hashtable , pero solo a HashMap , LinkedHashMap y ConcurrentHashMap .

Para tu información, actualmente,

  • TREEIFY_THRESHOLD = 8 : si un grupo contiene más de 8 nodos, la lista enlazada se transforma en un árbol equilibrado.
  • UNTREEIFY_THRESHOLD = 6 : cuando un grupo se vuelve demasiado pequeño (debido a la eliminación o al cambio de tamaño), el árbol se convierte de nuevo a la lista vinculada.

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

También tenga en cuenta que Hashtable extiende la clase de Dictionary , que, como el estado de Javadocs , está obsoleta y ha sido reemplazada por la interfaz de Map .

Además de todos los otros aspectos importantes que ya se mencionaron aquí, la API de colecciones (por ejemplo, la interfaz del mapa) se está modificando todo el tiempo para cumplir con las "últimas y mejores" incorporaciones a las especificaciones de Java.

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

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

versus el antiguo enfoque 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"];

Actualización: No, no aterrizarán en 1.8 ... :(

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

Basado en la información here , recomiendo ir con HashMap. Creo que la mayor ventaja es que Java evitará que lo modifiques mientras estés iterando sobre él, a menos que lo hagas a través del iterador.

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

Esta pregunta a menudo se hace en una entrevista para verificar si el candidato entiende el uso correcto de las clases de recolección y si conoce las soluciones alternativas disponibles.

  1. La clase HashMap es aproximadamente equivalente a Hashtable, excepto que no está sincronizada y permite 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 está sincronizado.
  4. El iterador en el HashMap es a prueba de fallos, mientras que el enumerador para el Hashtable no lo es y lanza la excepción ConcurrentModificationException si cualquier otro hilo modifica el mapa estructuralmente agregando o eliminando cualquier elemento, excepto el propio método remove () del iterador. Pero esto no es un comportamiento garantizado y lo hará JVM con el mejor esfuerzo.

Nota sobre algunos términos importantes

  1. Sincronizado significa que solo un hilo puede modificar una tabla hash en un momento determinado. Básicamente, significa que cualquier subproceso 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. Fail-safe es relevante desde el contexto de los iteradores. Si se ha creado un iterador en un objeto de colección y algún otro hilo intenta modificar el objeto de colección "estructuralmente", se lanzará una excepción de modificación concurrente. Sin embargo, es posible que otros subprocesos invocen el método "set" ya que no modifica la colección "estructuralmente". Sin embargo, si antes de llamar "set", la colección se modificó estructuralmente, se lanzará "IllegalArgumentException".
  3. La modificación estructural significa eliminar o insertar un elemento que podría cambiar efectivamente la estructura del mapa.

HashMap puede ser sincronizado por

Map m = Collections.synchronizeMap(hashMap);

El mapa 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 colección mejoran en gran medida la expresividad de la interfaz, como se explica más adelante en esta sección. El mapa le permite iterar sobre claves, valores o pares clave-valor; Hashtable no proporciona la tercera opción. El mapa proporciona una forma segura de eliminar entradas en medio de la iteración; Hashtable no lo hizo. Finalmente, Map corrige una deficiencia menor en la interfaz Hashtable. Hashtable tiene un método llamado contiene, que devuelve verdadero si la tabla tiene un valor determinado. Dado su nombre, esperaría que este método devuelva verdadero si el Hashtable contuviera una clave dada, porque la clave es el mecanismo de acceso principal para un Hashtable. La interfaz del Mapa elimina esta fuente de confusión al cambiar el nombre del método que contieneValor. Además, esto mejora la consistencia de la interfaz: contiene valores paralelos aViene de clave.

La interfaz del mapa

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

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

Hay 5 diferenciaciones básicas con HashTable y HashMaps.

  1. Maps le permite iterar y recuperar claves, valores y ambos pares clave-valor también, donde la tabla hash no tiene toda esta capacidad.
  2. En Hashtable hay una función contiene (), que es muy confuso de usar. Debido a que el significado de contiene es ligeramente divergente. ¿Significa si contiene clave o contiene valor? difícil de entender Lo mismo en los mapas, tenemos las funciones ContainsKey () y ContainsValue (), que son muy fáciles de entender.
  3. En hashmap puedes eliminar el elemento mientras lo haces, de forma segura. Donde como no es posible en tablas hash.
  4. Las tablas hash están sincronizadas de forma predeterminada, por lo que se pueden usar con varios subprocesos fácilmente. Donde los HashMaps no están sincronizados de forma predeterminada, por lo tanto, se pueden usar con un solo hilo. Pero aún puede convertir HashMap a sincronizado usando la función synchronizedMap (Map m) de la clase util util Collections.
  5. HashTable no permitirá claves nulas o valores nulos. Where como HashMap permite una clave nula y varios valores nulos.

Hay muchas buenas respuestas ya publicadas. Estoy agregando algunos puntos nuevos y resumiéndolos.

HashMap y Hashtable se utilizan para almacenar datos en forma de clave y valor . Ambos están utilizando la técnica de hash para almacenar claves únicas. Pero hay muchas diferencias entre las clases HashMap y Hashtable que se dan 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 varios 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 Iterator.
  7. Iterador en HashMap es rápido de fallas.
  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 puede ser desincronizado.
  6. Hashtable es atravesado por Enumerator e Iterator.
  7. El enumerador en Hashtable no es rápido.
  8. Hashtable hereda clase de diccionario.

Lectura adicional ¿Cuál es la diferencia entre HashMap y Hashtable en Java?

Hay varias diferencias entre HashMap y Hashtable en Java:

  1. Hashtable está synchronized , mientras que HashMap no lo está. Esto hace que HashMap sea ​​mejor para aplicaciones sin subprocesos, ya que los Objetos no sincronizados normalmente tienen un mejor desempeño que los sincronizados.

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

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

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

Otra diferencia clave entre hashtable y hashmap es que Iterator en HashMap es rápido, mientras que el enumerador para 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 de eliminación () de Iterator. Pero esto no es un comportamiento garantizado y será realizado por JVM con el mejor esfuerzo ".

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

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

Tenga en cuenta que HashTable era una clase heredada antes de que se introdujera Java Collections Framework (JCF) y luego se modificó para implementar la interfaz de Map . Así fue Vector y Stack .

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

Aquí está la hoja de trucos de la colección de Java que encontrará útil. Observe que el bloque gris contiene la clase heredada HashTable, Vector y Stack.

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

Un modismo muy común es "verificar y luego poner", es decir, buscar una entrada en el Mapa y agregarla si no existe. Esto no es en modo alguno una operación atómica, ya sea que utilice Hashtable o HashMap.

Se puede obtener un HashMap sincronizado de manera equivalente mediante:

Collections.synchronizedMap(myMap);

Pero para implementar correctamente esta lógica necesitas una sincronización adicional del formulario:

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

Incluso la iteración sobre las entradas de un Hashtable (o un HashMap obtenido por Collections.synchronizedMap) no es segura para subprocesos a menos que también evite que el Mapa se modifique a través de una sincronización adicional.

Las implementaciones de la interfaz de ConcurrentMap (por ejemplo, ConcurrentHashMap ) resuelven algo de esto al incluir semánticas seguras de subprocesos que se activan y ejecutan , como:

ConcurrentMap.putIfAbsent(key, value);

HashTable es una clase heredada en el jdk que ya no debería usarse. Reemplace los usos de la misma con ConcurrentHashMap . Si no necesita seguridad de subprocesos, use HashMap que no es threadsafe pero es más rápido y usa menos memoria.

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

Hablando en serio, es mejor que te mantengas alejado de Hashtable . Para aplicaciones de un solo hilo, no necesita la sobrecarga adicional de sincronización. Para aplicaciones altamente concurrentes, la sincronización paranoica puede provocar inanición, puntos muertos o pausas innecesarias de recolección de basura. Como señaló Tim Howland, en su lugar podría usar ConcurrentHashMap .

HashMap y Hashtable 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 manera que tenga como máximo ocho elementos (colisiones) en cualquier cubo y agitará los elementos muy bien para los tipos de elementos generales. Sin embargo, la implementación de Hashtable 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 utilizando, 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 para algunos casos.

Aparte de las diferencias obvias discutidas ampliamente en esta pregunta, veo el Hashtable como un auto de "manejo manual" en el que tienes mejor control sobre el hash y al HashMap como la contraparte del "auto drive" que generalmente funcionará bien.

HashMapEs emulado y por lo tanto utilizable en el GWT client codeque Hashtableno lo es.

Hashtable es considerado código heredado. No hay nada sobre Hashtable que no se pueda hacer usando HashMap o derivaciones de HashMap , así que para el nuevo código, no veo ninguna justificación para volver a Hashtable .

Hashtable es similar al HashMap y tiene una interfaz similar. Se recomienda que utilice HashMap , a menos que necesite soporte para aplicaciones heredadas o que necesite sincronización, ya que los métodos de Hashtables están sincronizados. Así que en tu caso, ya que no eres multihilo, HashMaps es tu mejor apuesta.

Una Collection , a veces llamada contenedor, es simplemente un objeto que agrupa múltiples elementos en una sola unidad. Collection se utilizan para almacenar, recuperar, manipular y comunicar datos agregados. Un marco de colecciones W es una arquitectura unificada para representar y manipular colecciones.

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

« Superclase, legado y miembro del Framework Collection.

Hashtable es una clase heredada introducida en JDK1.0 , que es una subclase de clase de diccionario. Desde JDK1.2 Hashtable ha sido rediseñado para implementar la interfaz de Map para hacer un miembro del marco de recopilación. HashMap es miembro de Java Collection Framework desde el principio 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 el número 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 una " collision hash ", un solo depósito almacena varias entradas, que deben buscarse de forma secuencial. El factor de carga es una medida de qué tan llena está permitida la tabla hash antes de que su capacidad se incremente automáticamente.

HashMap construye una tabla hash vacía con la capacidad inicial predeterminada (16) y el factor de carga predeterminado (0,75). Where as Hashtable construye una tabla hash vacía con una capacidad inicial predeterminada (11) y un factor de carga / proporción de relleno (0,75).

« Modificación estructural en caso de colisión de hachís.

HashMap , Hashtable en caso de colisiones hash, almacenan las entradas del mapa en listas vinculadas. Desde Java8 para HashMap si el hash bucket supera un cierto umbral, ese bucket pasará de la linked list of entries to a balanced tree . que mejoran el desempeño en el peor de los casos de O (n) a O (log n). Al convertir la lista en un árbol binario, el código hash se utiliza como una variable de bifurcación. Si hay dos códigos hash diferentes en el mismo grupo, 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 para que se pueda mantener un cierto orden. Es una buena práctica hacer que las claves de HashMap comparable . Al agregar entradas si el tamaño del grupo alcanza TREEIFY_THRESHOLD = 8 convierte la lista enlazada de entradas en un árbol balanceado, al eliminar las entradas menos que TREEIFY_THRESHOLD y, como máximo, UNTREEIFY_THRESHOLD = 6 reconvertirá el árbol balanceado en una lista enlazada de entradas. Java 8 SRC , stackpost

« Recopilación de vista de colección, Fail-Fast y Fail-Safe

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

Iterator es un error rápido en la naturaleza. es decir, genera la excepción ConcurrentModificationException si una colección se modifica mientras se iteran por un método distinto a su propio método remove (). Donde como Enumeration es a prueba de fallos en la naturaleza. No lanza ninguna excepción si una colección se modifica mientras se está iterando.

De acuerdo con los documentos API de Java, Iterator siempre se prefiere a la enumeración.

NOTA: La funcionalidad de la interfaz de enumeración está duplicada por la interfaz del iterador. Además, Iterator agrega una operación de eliminación opcional y tiene nombres de métodos más cortos. Las nuevas implementaciones deben considerar el uso de Iterator con preferencia a la enumeración.

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

  • Cada valor de HashMapEntry es volatile lo que garantiza una consistencia de grano fino para las modificaciones en HashMapEntry y las lecturas subsiguientes; Cada lectura refleja la actualización más reciente

  • Los iteradores y las enumeraciones son a prueba de fallas, lo que refleja 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 consistencia. No lanzan ConcurrentModificationException. Sin embargo, los iteradores están diseñados para ser utilizados por un solo hilo a la vez.

  • Al igual que Hashtable pero a diferencia de HashMap , esta clase no permite que se utilice el valor 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 un máximo de una clave nula y cualquier número de valores nulos. Where como Hashtable no permite ni una sola clave nula ni un valor nulo, si la clave o el valor nulo es entonces arroja NullPointerException. Example

« Sincronizado, hilo seguro

Hashtable está sincronizado internamente. Por lo tanto, es muy seguro utilizar Hashtable en aplicaciones de subprocesos múltiples. Donde como HashMap no está sincronizado internamente. Por lo tanto, no es seguro usar HashMap en aplicaciones multihilo sin sincronización externa. Puede sincronizar externamente HashMap usando el método Collections.synchronizedMap() .

« Rendimiento

Como Hashtable está sincronizado internamente, esto hace que Hashtable sea ​​un poco más lento que HashMap .

@Ver

Hashtable:

Hashtable es una estructura de datos que conserva los valores del par clave-valor. No permite nulo tanto para las claves como para los valores. Obtendrá un NullPointerExceptionvalor nulo si agrega. Está sincronizado. Así que viene con su costo. Sólo un hilo puede acceder a HashTable 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)); } }

HashMap:

HashMap es como Hashtable pero también acepta un par de valores clave. Permite nulo tanto para las claves como para los valores. Su rendimiento mejor es mejor que HashTable, porque lo 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)); } }

HashMap y HashTable

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

1) Hashtable y Hashmap implementan la interfaz java.util.Map 2) Tanto Hashmap como Hashtable son la colección basada en hash. y trabajando en hash. por lo que estos son la similitud 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 tiene un mejor rendimiento porque no es seguro para subprocesos mientras que el rendimiento de Hashtable no es mejor porque es seguro para subprocesos. por lo que múltiples hilos no pueden acceder a Hashtable al mismo tiempo.

Sincronización o hilo seguro :

Hash Map no está sincronizado, por lo tanto, no es seguro y no puede compartirse 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 :

Iterator en HashMap es un iterador rápido de fallas, mientras que el enumerador para 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.

Superclase y Legado :

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

Rendimiento :

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

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

HashMap: - Es una clase disponible dentro del paquete java.util y se usa para almacenar el elemento en formato de clave y valor.

Hashtable: -Es una clase heredada que se reconoce dentro del marco de recopilación.

HashMaps le da libertad de sincronización y depuración es mucho más fácil

Mi pequeña contribución:

  1. Primero y más importante entre diferentes Hashtabley HashMapes que, HashMapno es seguro para subprocesos, mientras que Hashtablees una colección segura para subprocesos.

  2. La segunda diferencia importante entre Hashtabley HashMapes el rendimiento, ya HashMapque no está sincronizado, funciona mejor que Hashtable.

  3. La tercera diferencia en Hashtablevs HashMapes que Hashtablees una clase obsoleta y que deberías usar ConcurrentHashMapen lugar de Hashtableen Java.

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

3) HashMap permite valores nulos en él, mientras que Hashtable no lo hace.

  • HashTable está sincronizado, si lo está utilizando en un solo hilo, puede usar docs.oracle.com/javase/7/docs/api/java/util/HashMap.html , 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 simultáneamente, y al menos uno de los subprocesos modifica el mapa estructuralmente, debe sincronizarse externamente. Youn 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 como valor. HashMap puede contener una clave nula y valores nulos.

  • Los iteradores devueltos por Map son rápidos, si el mapa se modifica estructuralmente en cualquier momento después de que se crea el iterador, de cualquier forma, excepto a través del propio método de eliminación del iterador, el iterador emitirá una excepción ConcurrentModificationException . Por lo tanto, ante una modificación concurrente, el iterador falla de manera rápida y limpia, en lugar de arriesgarse a comportamientos arbitrarios y no deterministas en un momento indeterminado en el futuro. Mientras que las enumeraciones devueltas por los métodos de elementos y claves de Hashtable no son a prueba de fallas.

  • HashTable y HashMap son miembros de Java Collections Framework (desde la plataforma Java 2 v1.2, HashTable se modificó para implementar la interfaz de Map).

  • HashTable se considera un código heredado, la documentación recomienda utilizar ConcurrentHashMap en lugar de Hashtable si se desea una implementación altamente concurrente segura para subprocesos.

  • HashMap no garantiza el orden en que se devuelven los elementos. Para HashTable, creo que es lo mismo, pero no estoy del todo seguro, no encuentro un recurso que lo indique claramente.