1. La diferencia entre hashmap y hashtable
Primero veamos la definición de dos clases
Hashtable de clase pública extiende el mapa de implementos de diccionario, clonable, java.io.serializable
HASHMAP de clase pública extiende AbstractMap Implements Map, clonable, serializable
Se puede ver que el hashtable herede del diccionario y el hashmap hereda de abstract map
El método Put de Hashtable es el siguiente
public sincronizado v put (k key, valor v) {// ######### Tenga en cuenta aquí 1 // Asegúrese de que el valor no sea nulo si (valor == null) {// ###### Nota aquí 2 tire nuevo nullPointerException (); } // Asegúrese de que la tecla no esté aún en el hashtable. Pestaña de entrada [] = tabla; int hash = key.hashcode (); // ####### Nota aquí 3 int index = (hash & 0x7ffffff) % tab.length; for (entrada e = tab [index]; e! = null; e = e.next) {if ((e.hash == hash) && e.key.equals (key)) {v old = e.value; e.value = valor; regresar viejo; }} modcount ++; if (count> = umbral) {// Rehash la tabla si se excede el umbral rehash (); tab = tabla; index = (hash & 0x7ffffff) % tab.length; } // Crea la nueva entrada. Entrada e = tab [índice]; pestaña [índice] = nueva entrada (hash, clave, valor, e); contar ++; regresar nulo; } Nota 1 El método es sincrónico
El método de nota 2 no permite valor == nulo
Nota 3 El método llama al método hashcode de la clave. Si Key == NULL, se lanzará una excepción de puntero nulo. El método Put de HashMap es el siguiente.
public v put (k key, valor v) {// ######### Nota aquí 1 if (clave == null) // ######## Nota aquí 2 return PutfornullKey (valor); int hash = hash (key.hashcode ()); int i = indexfor (hash, table.length); para (entrada e = tabla [i]; e! = null; e = e.next) {objeto k; if (e.hash == hash && ((k = e.key) == key || key.equals (k))) {v OldValue = e.Value; e.value = valor; E.RecordAccess (esto); devolver OldValue; }} modcount ++; Addentry (hash, clave, valor, i); // ####### Nota Aquí regresa NULL; } Nota 1 El método es asíncrono
El método de la nota 2 permite la tecla == NULL
Nota 3 El método no hace ninguna llamada al valor, por lo que se permite que sea nulo.
Reponer:
Hashtable tiene un método contiene, que puede causar fácilmente malentendidos, por lo que se ha eliminado en Hashmap.
Por supuesto, ambas clases usan los métodos ContinsKey y ContinsValue.
| Mapache | Hashtable | |
| Clase madre | Mapa de abstracto | Diccionario |
| ¿Está sincronizado? | No | Sí |
| K, Can V Null | Sí | No |
Hashmap es una implementación ligera de hashtable (implementación no segura). Todos completan la interfaz del mapa. La principal diferencia es que hashmap permite teclas nulas. Debido a la no segura de huellas, puede ser más eficiente que el hashtable.
Hashmap permite que NULL como clave o valor de una entrada, mientras que Hashtable no.
Hashmap elimina el método de hashtable contiene y lo cambia a ContinsValue y contiene Key. Porque el método Contiene es fácil de causar malentendidos.
Hashtable hereda de la clase de diccionario, y hashmap es una implementación de la interfaz de mapas introducida por Java 1.2.
La mayor diferencia es que el método hashtable es sincronizado, mientras que HashMap no lo es. Cuando múltiples hilos acceden a hashtable, no necesitan sincronizarse para sus métodos ellos mismos, y HASHMAP debe proporcionar sincronización externa (colección.synchronizedMap).
Los algoritmos hash/rehash utilizados por Hashtable y HashMap son más o menos los mismos, por lo que no habrá una gran diferencia en el rendimiento.
Resumir:
Los valores clave en hashmap pueden estar vacíos y son asíncronos
No se permite que el valor clave en hashtable sea nulo y se sincronice
La herencia es diferente, pero ambos implementan la interfaz del mapa
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.