Diferencias entre HashMap y Hashtable?

Tenga en cuenta que muchas de las respuestas indican que la tabla Hash está sincronizada. En la práctica esto te compra muy poco. La sincronización está en los métodos accessor / mutator detendrá dos subprocesos agregando o quitando del mapa simultáneamente, pero en el mundo real a menudo necesitará sincronización adicional.

Un modismo muy común es "check then put", es decir, buscar una entrada en el Mapa y agregarla si aún no existe. Esto no es de ninguna manera una operación atómica si utiliza Hashtable o HashMap.

Se puede obtener un HashMap sincronizado de forma equivalente:

Collections.synchronizedMap(myMap);

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

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

Incluso iterando sobre las entradas de una Hashtable (o un HashMap obtenido por Colecciones.synchronizedMap) no es seguro para subprocesos a menos que también proteja el mapa de ser modificado a través de sincronización adicional.

Implementaciones de la ConcurrentMap interfaz (por ejemplo ConcurrentHashMap) resuelve algo de esto incluyendo semántica de verificación-acto segura de subprocesos como:

ConcurrentMap.putIfAbsent(key, value);

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

Esta pregunta se hace a menudo en la entrevista para comprobar si el candidato entiende el uso correcto de las clases de colección y está al tanto de las soluciones alternativas disponibles.

1. La clase HashMap es aproximadamente equivalente a Hashtable, excepto que no está sincronizada y permite nulls. (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 mantenga constante en el tiempo.
3. HashMap es no sincronizado mientras que Hashtable está sincronizado.
4. El iterador en el HashMap es a prueba de fallos mientras que el enumerador para la Hashtable no lo es y lanza ConcurrentModificationException si cualquier otro Subproceso 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 será hecho por JVM en el mejor esfuerzo.

Nota sobre Algunos Términos Importantes

1. Sincronizado significa que solo un hilo puede modificar una tabla hash en un momento dado. 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. 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 subproceso intenta modificar el objeto de colección "estructuralmente", se lanzará una excepción de modificación concurrente. Sin embargo, es posible para otros hilos para invocar el método " set "ya que no modifica la colección"estructuralmente". Sin embargo, si antes de llamar a "set", la colección ha sido modificada estructuralmente, se lanzará "IllegalArgumentException".
3. La 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 iteración por Enumeración objeto. Vistas de la colección mejorar en gran medida 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 proporciona la tercera opción. El mapa proporciona una forma segura para 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 contains, que devuelve true si el Hashtable contiene un valor dado. Dado su nombre, usted esperaría esto método para devolver true si la tabla Hash contenía una clave dada, porque la clave es el mecanismo de acceso principal para una tabla Hash. mapeo interfaz elimina esta fuente de confusión al cambiar el nombre del método containsValue. Además, esto mejora la consistencia de la interfaz - containsValue parallels containsKey.

La Interfaz del Mapa

HashMap: Una implementación de la interfaz Map que utiliza códigos hash para indexar un array. Hashtable: Hola, 1998 llamado. Quieren recuperar su API de colecciones.

En serio, sin embargo, es mejor que te mantengas alejado de Hashtable por completo. Para aplicaciones de subproceso único, no necesita la sobrecarga adicional de la sincronización. Para aplicaciones altamente concurrentes, la sincronización paranoica podría conducir a inanición, bloqueos o pausas innecesarias de recolección de basura. Como Tim Howland señaló, usted podría use ConcurrentHashMap en su lugar.

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

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

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

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 Dictionary, que como el estado Javadocs, es obsoleta y ha sido reemplazada por la interfaz Map.

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.

Java Collection Matrix

Hashtable es similar a HashMap y tiene una interfaz similar. Se recomienda usar HashMap, a menos que necesite soporte para aplicaciones heredadas o necesite sincronización, ya que los métodos Hashtables están sincronizados. Así que en su caso como usted no está multi-threading, HashMaps son su mejor apuesta.

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

HashMap y Hashtable ambos se utilizan para almacenar datos en forma de clave y valor. Ambos están utilizando la técnica de hashing 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 hilos y no se puede compartir entre muchos hilos sin la adecuada código de sincronización.
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 que el HashMap esté sincronizado llamando a este código
   Map m = Collections.synchronizedMap(HashMap);
6. HashMap es atravesado por el Iterador.
7. El iterador en HashMap es fail-fast.
8. HashMap hereda la clase AbstractMap.

Hashtable

1. Hashtable está sincronizado. Es seguro para hilos y se puede compartir con muchos hilos.
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. El enumerador en Hashtable no es fail-fast.
8. Hashtable hereda la clase de diccionario.

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

Otra diferencia clave entre hashtable y hashmap es que el Iterador en el HashMap es fail-fast mientras que el enumerador para la Hashtable no lo es y lanza 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 será hecho por JVM en el mejor esfuerzo."

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

Además de todos los otros aspectos importantes ya mencionados aquí, la API de colecciones (por ejemplo, la interfaz de mapa) se está modificando todo el tiempo para ajustarse a las "últimas y mejores" adiciones 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"];

Actualización: No, no lo harán tierra en 1.8... :(

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

• HashTable 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 simultáneamente, y al menos uno de los subprocesos modifica el mapa estructuralmente, debe sincronizarse externamente. Usted puede envolver un mapa no sincronizado en uno sincronizado usando:

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

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

• Los iteradores devueltos por Map son fail-fast, si el mapa se modifica estructuralmente en cualquier momento después de que se cree el iterador, de cualquier manera excepto a través del propio método remove del iterador, el iterador lanzará un ConcurrentModificationException. Por lo tanto, frente a la modificación concurrente, el iterador falla rápida y limpiamente, en lugar de arriesgar un comportamiento arbitrario y no determinista a un nivel indeterminado tiempo en el futuro. Mientras que las Enumeraciones devueltas por los métodos keys y elements de Hashtable no son fail-fast.

• HashTable y HashMap son miembros del Java Collections Framework (desde Java 2 platform v1.2, HashTable se adaptó para implementar la interfaz de mapa).

• HashTable se considera código heredado, la documentación aconseja usar ConcurrentHashMap en lugar de Hashtable si un subproceso seguro altamente concurrente se desea su aplicación.

• 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 ressource que indique claramente eso.

HashMap y Hashtable tienen diferencias algorítmicas significativas también. Nadie ha mencionado esto antes, así que es por eso que lo estoy mencionando. HashMap construirá una tabla hash con 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 tipos de elementos generales. Sin embargo, la implementación Hashtable proporciona un control mejor y más fino sobre el hash si sabe lo que está haciendo, es decir, puede arreglar 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 para algunos casos.

Aparte de las diferencias obvias discutidas ampliamente en esta pregunta, veo la tabla de Hash como un automóvil de "manejo manual" donde tiene un mejor control sobre el hash y el HashMap como la contraparte de "manejo automático" que generalmente funcionará bien.

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 de lo contrario son iguales en términos de funcionalidad.

Basado en la información aquí, yo recomendaría ir con HashMap. Creo que la mayor ventaja es que Java le impedirá modificarlo mientras está iterando sobre él, a menos que lo haga a través del iterador.

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

A Collection - a veces llamado contenedor - es simplemente un objeto que agrupa varios elementos en una sola unidad. Collection 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.

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

" Miembro del Marco de Superclase, Legado y Colección

Hashtable es una clase heredada introducida en JDK1.0, que es una subclase de Dictionary class. From JDK1.2 Hashtable is re-engineered to implement the Map interface to make a member of collection framework. 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 el factor de Carga

La capacidad es el número de cubos 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 "hashcollision", un solo cubo almacena varias entradas, que deben buscarse secuencialmente. El factor de carga es una medida de cuán llena se permite que se llene 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). Donde as Hashtable construye una hashtable vacía con una capacidad inicial predeterminada(11) y relación factor de carga / llenado (0.75).

" modificación Estructural en caso de colisión de hash

HashMap, Hashtable en caso de colisiones hash, almacenan las entradas del mapa en listas vinculadas. De Java8 para HashMap si el cubo hash crece más allá de un cierto umbral, ese cubo cambiará de linked list of entries to a balanced tree. que mejore el rendimiento en el peor de los casos de O(n) a O(log n). Al convertir la lista a árbol binario, hashcode se utiliza como una variable de ramificación. Si hay dos hashcodes diferentes en el mismo cubo, uno se considera más grande y va a la derecha del árbol y otro a la izquierda. Pero cuando ambos hashcodes son iguales, HashMap asume que las claves son comparables, y compara la clave para determinar la dirección para que se pueda mantener algún orden. Es una buena práctica para hacer las teclas de HashMap comparable . Al añadir entradas si el tamaño del cubo alcanza TREEIFY_THRESHOLD = 8 convertir la lista de entradas enlazadas a un árbol balanceado, al eliminar entradas menores que TREEIFY_THRESHOLD y como máximo UNTREEIFY_THRESHOLD = 6 reconvertirán el árbol balanceado a una lista de entradas enlazadas. ^{Java 8 SRC, stackpost}

" Iteración de la vista de colección, Rápida y a prueba de fallos

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

Iterator es un fail-fast en la naturaleza. es decir, lanza ConcurrentModificationException si se modifica una colección mientras se itera de forma distinta a su propio método remove (). Donde como Enumeration es a prueba de fallos en la naturaleza. No genera ninguna excepción si se modifica una colección mientras se itera.

De acuerdo con los documentos de la API de Java, el Iterador siempre se prefiere a la Enumeración.

_{NOTA: La funcionalidad de la interfaz de Enumeración es duplicada por la interfaz del Iterador. Además, el Iterador añade un operación de eliminación opcional, y tiene nombres de método más cortos. Las nuevas implementaciones deben considerar el uso del Iterador en lugar de la Enumeración.}

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

• Cada valor de HashMapEntry s es volátil asegurando así la consistencia de grano fino para modificaciones contendidas y lecturas posteriores; cada lectura refleja la actualización más reciente completada

• Iteradores y Enumeraciones son a prueba de fallos - reflejando el estado en algún momento desde la creación de iterador / enumeración; esto permite lecturas simultáneas y modificaciones a costa de una menor consistencia. No tirar 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 null se use 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 null y cualquier número de valores null. Donde as Hashtable no permite ni una sola clave null y valor null, si la clave o valor null es entonces arroja NullPointerException. ^Ejemplo

" Sincronizado, Hilo seguro

Hashtable está sincronizado internamente. Por lo tanto, es muy seguro usar Hashtable en aplicaciones multihilo. Donde as HashMap no está sincronizado internamente. Por lo tanto, no es seguro usar HashMap en aplicaciones multihilo sin sincronización externa. Usted puede sincronizar externamente HashMap usando el método Collections.synchronizedMap().

" el Rendimiento

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

@Ver

• Un árbol rojo–negro es una especie de árbol de búsqueda binaria de auto-equilibrio
• Mejora del rendimiento para HashMap en Java 8

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

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

* La mejora mencionada no se ha aplicado a Hashtable todavía, sino solo a HashMap, LinkedHashMap, y ConcurrentHashMap.

FYI, actualmente,

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

1.Hashmap y HashTable ambos almacenan la clave y el valor.

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

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 HashTable no tiene toda esta capacidad.
2. En Hashtable hay una función contains(), que es muy confusa de usar. Porque el significado de contiene se desvía ligeramente. ¿Si significa contiene clave o contiene valor? difícil de entender. Lo mismo en los mapas tenemos containsKey () y Funciones containsValue (), que son muy fáciles de entender.
3. En hashmap se puede eliminar el elemento mientras se itera, de forma segura. donde como no es posible en los hashtables.
4. Los HashTables están sincronizados por defecto, por lo que se pueden usar fácilmente con múltiples subprocesos. Donde como HashMaps no están sincronizados de forma predeterminada, por lo que se puede utilizar con un solo hilo. Pero aún puede convertir HashMap a sincronizado mediante el uso de Colecciones util class synchronizedMap (Map m) función.
5. HashTable no permitirá claves null o valores null. Donde as HashMap permite una clave nula y múltiples valores nulos.

Mi pequeña contribución:

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

2. La Segunda diferencia importante entre Hashtable y HashMap es el rendimiento, ya que HashMap no está sincronizado se desempeñan mejor que Hashtable.

3. La tercera diferencia en Hashtable vs HashMap es que Hashtable es una clase obsoleta y debería usar ConcurrentHashMap en lugar de Hashtable en Java.

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

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

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

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

Hashtable: - Es una clase heredada que está siendo reconocida dentro de collection framework

Hashtable:

Hashtable es una estructura de datos que conserva los valores del par clave-valor. No permite null tanto para las claves como para los valores. Obtendrá un NullPointerException si agrega un valor null. Está sincronizado. Así que viene con su costo. Solo 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 pares de valores clave. Se permite null tanto para las claves como para los valores. Su rendimiento mejor 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));

    }
}

HashMap y HashTable

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

1) Hashtable y Hashmap implementan java.útil.Interfaz de mapa 2) Tanto Hashmap como Hashtable son la colección basada en hash. y trabajando en hachís. así que estos son 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 hilos Mientras que HashTable es ThreadSafe
2) HashMap es mejor rendimiento sabio porque no es seguro hilo. mientras que el rendimiento de Hashtable no es mejor porque es seguro para hilos. por lo tanto, varios subprocesos no pueden acceder a Hashtable al mismo tiempo.

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

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

Sincronización o Thread Safe :

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

Claves null y valores null :

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

Iterando los valores :

Iterador en el HashMap es un iterador fail-fast mientras que el enumerador de la Hashtable no lo es y lanza ConcurrentModificationException si cualquier otro Subproceso modifica el mapa estructuralmente agregando o eliminando cualquier elemento excepto el propio método remove() del Iterador.

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.

Refiérase a http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java para ejemplos y preguntas de entrevistas y preguntas relacionadas con la colección Java