objetos - metodos de hashmap java




Diferencias entre HashMap y Hashtable? (20)

¿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 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.


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 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 .


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.


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 .


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 .


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));

    }
}

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.


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