El Tabla de picadillo La clase implementa una tabla hash, que asigna claves a valores. Cualquier objeto no nulo se puede utilizar como clave o como valor. Para almacenar y recuperar objetos de una tabla hash con éxito, los objetos utilizados como claves deben implementar el método hashCode y el método igual.
La clase java.util.Hashtable es una clase en Java que proporciona una estructura de datos clave-valor, similar a la interfaz Map. Era parte del marco de colecciones de Java original y se introdujo en Java 1.0.
Sin embargo, desde entonces la clase Hashtable se ha considerado obsoleta y, en general, se desaconseja su uso. Esto se debe a que fue diseñado antes de la introducción del marco de Colecciones y no implementa la interfaz Mapa, lo que dificulta su uso junto con otras partes del marco. Además, la clase Hashtable está sincronizada, lo que puede dar como resultado un rendimiento más lento en comparación con otras implementaciones de la interfaz Map.
En general, se recomienda utilizar la interfaz Map o una de sus implementaciones (como HashMap o ConcurrentHashMap) en lugar de la clase Hashtable.
Aquí hay un ejemplo de cómo usar la clase Hashtable:
Java
fusionar ordenación en java
import> java.util.Enumeration;> import> java.util.Hashtable;> public> class> Main {> >public> static> void> main(String[] args) {> >Hashtable hashtable =>new> Hashtable();> >// Adding elements to the hashtable> >hashtable.put(>'A'>,>1>);> >hashtable.put(>'B'>,>2>);> >hashtable.put(>'C'>,>3>);> >// Getting values from the hashtable> >int> valueA = hashtable.get(>'A'>);> >System.out.println(>'Value of A: '> + valueA);> >// Removing elements from the hashtable> >hashtable.remove(>'B'>);> >// Enumerating the elements of the hashtable> >Enumeration keys = hashtable.keys();> >while> (keys.hasMoreElements()) {> >String key = keys.nextElement();> >System.out.println(>'Key: '> + key +>', Value: '> + hashtable.get(key));> >}> >}> }> |
>
>Producción
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
En conclusión, si bien la clase Hashtable todavía existe en Java y aún se puede usar, generalmente se recomienda usar la interfaz Map o una de sus implementaciones.
Características de la tabla hash
- Es similar a HashMap, pero está sincronizado.
- Hashtable almacena el par clave/valor en la tabla hash.
- En Hashtable especificamos un objeto que se usa como clave y el valor que queremos asociar a esa clave. Luego se aplica un hash a la clave y el código hash resultante se utiliza como índice en el que se almacena el valor dentro de la tabla.
- La capacidad predeterminada inicial de la clase Hashtable es 11, mientras que loadFactor es 0,75.
- HashMap no proporciona ninguna enumeración, mientras que Hashtable no proporciona una enumeración rápida.
Declaración:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Tipo de parámetros:
- k – el tipo de claves mantenidas por este mapa
- EN – el tipo de valores mapeados
La jerarquía de Hashtable
Implementos de tabla hash Serializable , Clonable , Mapa interfaces y se extiende Diccionario . Las subclases directas son Propiedades, Valores predeterminados de UI .
Constructores:
Para crear una Hashtable, necesitamos importarla desde java.util.Hashtable . Hay varias formas en las que podemos crear una Hashtable.
1. Tabla hash(): Esto crea una tabla hash vacía con el factor de carga predeterminado de 0,75 y una capacidad inicial de 11.
Hashtable ht = nueva Hashtable();
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1 =>new> Hashtable();> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable();> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'one'>);> >ht1.put(>2>,>'two'>);> >ht1.put(>3>,>'three'>);> >ht2.put(>4>,>'four'>);> >ht2.put(>5>,>'five'>);> >ht2.put(>6>,>'six'>);> >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Producción
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Tabla hash (int capacidad inicial): Esto crea una tabla hash que tiene un tamaño inicial especificado por capacidad inicial y el factor de carga predeterminado es 0,75.
Hashtable ht = new Hashtable(int capacidadinicial);
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1 =>new> Hashtable(>4>);> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable(>2>);> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'one'>);> >ht1.put(>2>,>'two'>);> >ht1.put(>3>,>'three'>);> >ht2.put(>4>,>'four'>);> >ht2.put(>5>,>'five'>);> >ht2.put(>6>,>'six'>);> >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Producción
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Hashtable (tamaño int, relación de relleno flotante): Esta versión crea una tabla hash que tiene un tamaño inicial especificado por tamaño y una proporción de relleno especificada por fillRatio. Relación de llenado: Básicamente, determina qué tan llena puede estar una tabla hash antes de cambiar su tamaño hacia arriba y su valor se encuentra entre 0,0 y 1,0.
Hashtable ht = new Hashtable(int size, float fillRatio);
Java
si y si no en bash
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1> >=>new> Hashtable(>4>,>0>.75f);> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable(>3>,>0>.5f);> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'one'>);> >ht1.put(>2>,>'two'>);> >ht1.put(>3>,>'three'>);> >ht2.put(>4>,>'four'>);> >ht2.put(>5>,>'five'>);> >ht2.put(>6>,>'six'>);> >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Producción
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Tabla hash (Mapa m): Esto crea una tabla hash que se inicializa con los elementos en m.
Hashtable ht = nueva Hashtable (Mapa m);
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Map hm =>new> HashMap();> >// Inserting the Elements> >// using put() method> >hm.put(>1>,>'one'>);> >hm.put(>2>,>'two'>);> >hm.put(>3>,>'three'>);> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable(hm);> >// Print mappings to the console> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Producción
Mappings of ht2 : {3=three, 2=two, 1=one}> Ejemplo:
Java
// Java program to illustrate> // Java.util.Hashtable> import> java.util.*;> public> class> GFG {> >public> static> void> main(String[] args)> >{> >// Create an empty Hashtable> >Hashtable ht =>new> Hashtable();> >// Add elements to the hashtable> >ht.put(>'vishal'>,>10>);> >ht.put(>'sachin'>,>30>);> >ht.put(>'vaibhav'>,>20>);> >// Print size and content> >System.out.println(>'Size of map is:- '> + ht.size());> >System.out.println(ht);> >// Check if a key is present and if> >// present, print value> >if> (ht.containsKey(>'vishal'>)) {> >Integer a = ht.get(>'vishal'>);> >System.out.println(>'value for key'> >+>' 'vishal' is:- '> + a);> >}> >}> }> |
>
>Producción
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Realizar varias operaciones en Hashtable
1. Agregar elementos: Para agregar un elemento a la tabla hash, podemos usar el método put(). Sin embargo, el orden de inserción no se conserva en la tabla hash. Internamente, para cada elemento, se genera un hash separado y los elementos se indexan en función de este hash para hacerlo más eficiente.
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1 =>new> Hashtable();> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable();> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'Geeks'>);> >ht1.put(>2>,>'For'>);> >ht1.put(>3>,>'Geeks'>);> >ht2.put(>1>,>'Geeks'>);> >ht2.put(>2>,>'For'>);> >ht2.put(>3>,>'Geeks'>);> > >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
cual es el tamaño de mi monitor
>
>Producción
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Elementos cambiantes: Después de agregar los elementos, si deseamos cambiar el elemento, podemos hacerlo agregando nuevamente el elemento con el método put(). Dado que los elementos de la tabla hash se indexan mediante claves, el valor de la clave se puede cambiar simplemente insertando el valor actualizado de la clave que deseamos cambiar.
Java
// Java program to demonstrate> // updating Hashtable> import> java.io.*;> import> java.util.*;> class> UpdatesOnHashtable {> >public> static> void> main(String args[])> >{> >// Initialization of a Hashtable> >Hashtable ht> >=>new> Hashtable();> >// Inserting the Elements> >// using put method> >ht.put(>1>,>'Geeks'>);> >ht.put(>2>,>'Geeks'>);> >ht.put(>3>,>'Geeks'>);> > >// print initial map to the console> >System.out.println(>'Initial Map '> + ht);> > >// Update the value at key 2> >ht.put(>2>,>'For'>);> > >// print the updated map> >System.out.println(>'Updated Map '> + ht);> >}> }> |
>
>Producción
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Eliminación del elemento: Para eliminar un elemento del mapa, podemos utilizar el método remove(). Este método toma el valor de la clave y elimina la asignación de una clave de este mapa si está presente en el mapa.
Java
// Java program to demonstrate> // the removing mappings from Hashtable> import> java.io.*;> import> java.util.*;> class> RemovingMappingsFromHashtable {> >public> static> void> main(String args[])> >{> >// Initialization of a Hashtable> >Map ht> >=>new> Hashtable();> >// Inserting the Elements> >// using put method> >ht.put(>1>,>'Geeks'>);> >ht.put(>2>,>'For'>);> >ht.put(>3>,>'Geeks'>);> >ht.put(>4>,>'For'>);> >// Initial HashMap> >System.out.println(>'Initial map : '> + ht);> >// Remove the map entry with key 4> >ht.remove(>4>);> >// Final Hashtable> >System.out.println(>'Updated map : '> + ht);> >}> }> |
>
>Producción
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Recorrido de una tabla hash: Para iterar la tabla, podemos hacer uso de un bucle avanzado para . A continuación se muestra el ejemplo de iteración de una tabla hash.
Java
// Java program to illustrate> // traversal of Hashtable> import> java.util.Hashtable;> import> java.util.Map;> public> class> IteratingHashtable {> >public> static> void> main(String[] args)> >{> >// Create an instance of Hashtable> >Hashtable ht =>new> Hashtable();> >// Adding elements using put method> >ht.put(>'vishal'>,>10>);> >ht.put(>'sachin'>,>30>);> >ht.put(>'vaibhav'>,>20>);> > >// Iterating using enhanced for loop> >for> (Map.Entry e : ht.entrySet())> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
>Producción
vaibhav 20 vishal 10 sachin 30>
Trabajo interno de Hashtable
La estructura de datos de Hashtable es una matriz de depósitos que almacena los pares clave/valor en ellos. Hace uso de método hashCode() para determinar qué depósito debe asignar el par clave/valor.
La función hash ayuda a determinar la ubicación de una clave determinada en la lista de deseos. Generalmente, el código hash es un número entero no negativo que es igual para Objetos iguales y puede o no ser igual para Objetos desiguales. Para determinar si dos objetos son iguales o no, hashtable utiliza el método equals().
Es posible que dos Objetos diferentes tengan el mismo código hash. Esto se llama un colisión . Para resolver colisiones, hashtable utiliza una serie de listas. Los pares asignados a un único depósito (índice de matriz) se almacenan en una lista y la referencia de la lista se almacena en el índice de matriz.
Métodos de tabla hash
- k – El tipo de claves en el mapa.
- EN – El tipo de valores asignados en el mapa.
| MÉTODO | DESCRIPCIÓN |
|---|---|
| claro() | Borra esta tabla hash para que no contenga claves. |
| clon() | Crea una copia superficial de esta tabla hash. |
| calcular (tecla K, BiFunción ¿K? ¿súper V? extiende V> función de reasignación) declaración del caso verilog | Intenta calcular una asignación para la clave especificada y su valor asignado actual (o nulo si no hay ninguna asignación actual). |
| calcularSiAbsent(tecla K, Función extiende V> función de mapeo) | Si la clave especificada aún no está asociada con un valor (o está asignada a nulo), intenta calcular su valor usando la función de mapeo dada y lo ingresa en este mapa a menos que sea nulo. |
| ComputeIfPresent (tecla K, función de reasignación BiFunction) | Si el valor de la clave especificada está presente y no es nulo, intenta calcular una nueva asignación dada la clave y su valor asignado actual. |
| contiene (valor del objeto) | Prueba si alguna clave se asigna al valor especificado en esta tabla hash. |
| contiene clave (clave de objeto) | Prueba si el objeto especificado es una clave en esta tabla hash. |
| contieneValor(Valor del objeto) | Devuelve verdadero si esta tabla hash asigna una o más claves a este valor. |
| elementos() | Devuelve una enumeración de los valores de esta tabla hash. |
| conjunto de entrada() | Devuelve una vista de conjunto de las asignaciones contenidas en este mapa. |
| es igual(Objeto o) | Compara el objeto especificado con este mapa para determinar la igualdad, según la definición en la interfaz del mapa. |
| obtener (clave de objeto) | Devuelve el valor al que está asignada la clave especificada, o nulo si este mapa no contiene ninguna asignación para la clave. |
| código hash() | Devuelve el valor del código hash para este Mapa según la definición en la interfaz del Mapa. |
| esta vacio() | Prueba si esta tabla hash no asigna claves a valores. |
| llaves() | Devuelve una enumeración de las claves de esta tabla hash. |
| juego de llaves() | Devuelve una vista de conjunto de las claves contenidas en este mapa. |
| fusionar (tecla K, valor V, función de reasignación BiFunction) | Si la clave especificada aún no está asociada con un valor o está asociada con un valor nulo, la asocia con el valor no nulo dado. |
| poner (tecla K, valor V) | Asigna la clave especificada al valor especificado en esta tabla hash. |
| ponerTodo(Mapa t) | Copia todas las asignaciones del mapa especificado a esta tabla hash. |
| refrito() | Aumenta la capacidad y reorganiza internamente esta tabla hash, para acomodar y acceder a sus entradas de manera más eficiente. |
| eliminar(clave de objeto) | Elimina la clave (y su valor correspondiente) de esta tabla hash. |
| tamaño() | Devuelve el número de claves en esta tabla hash. |
| Encadenar() | Devuelve una representación de cadena de este objeto Hashtable en forma de un conjunto de entradas, entre llaves y separadas por caracteres ASCII (coma y espacio). |
| valores() | Devuelve una vista de Colección de los valores contenidos en este mapa. |
Métodos declarados en la interfaz java.util.Map
| MÉTODO | DESCRIPCIÓN |
|---|---|
| para cada uno (acción BiConsumer) | Realiza la acción dada para cada entrada en este mapa hasta que se hayan procesado todas las entradas o la acción genere una excepción. |
| getOrDefault(Clave de objeto, V valor predeterminado) | Devuelve el valor al que está asignada la clave especificada, o defaultValue si esta asignación no contiene ninguna asignación para la clave. |
| putIfAbsent(tecla K, valor V) | Si la clave especificada aún no está asociada con un valor (o está asignada a nulo), la asocia con el valor dado y devuelve nulo; de lo contrario, devuelve el valor actual. |
| eliminar(Clave de objeto, Valor del objeto) | Elimina la entrada para la clave especificada solo si actualmente está asignada al valor especificado. |
| reemplazar (tecla K, valor V) | Reemplaza la entrada de la clave especificada solo si actualmente está asignada a algún valor. |
| reemplazar (tecla K, V valor antiguo, V valor nuevo) | Reemplaza la entrada de la clave especificada solo si actualmente está asignada al valor especificado. |
| reemplazar todo (función BiFunction) | Reemplaza el valor de cada entrada con el resultado de invocar la función dada en esa entrada hasta que se hayan procesado todas las entradas o la función genere una excepción. |
Debe leer:
- Diferencias entre HashMap y HashTable en Java
Ventajas de Hashtable:
- Seguro para subprocesos: la clase Hashtable es segura para subprocesos, lo que significa que varios subprocesos pueden acceder a ella simultáneamente sin causar daños en los datos u otros problemas de sincronización.
- Fácil de usar: la clase Hashtable es fácil de usar y proporciona una funcionalidad básica de estructura de datos clave-valor, que puede resultar útil en casos sencillos.
Desventajas de Hashtable:
- Obsoleto: la clase Hashtable se considera obsoleta y, en general, se desaconseja su uso. Esto se debe a que fue diseñado antes de la introducción del marco de Colecciones y no implementa la interfaz Mapa, lo que dificulta su uso junto con otras partes del marco.
- Funcionalidad limitada: la clase Hashtable proporciona una funcionalidad básica de estructura de datos clave-valor, pero no proporciona la gama completa de funcionalidades que están disponibles en la interfaz Map y sus implementaciones.
- Rendimiento deficiente: la clase Hashtable está sincronizada, lo que puede dar como resultado un rendimiento más lento en comparación con otras implementaciones de la interfaz Map, como HashMap o ConcurrentHashMap.
Libros de referencia:
- Colecciones Java de Maurice Naftalin y Philip Wadler. Este libro proporciona una descripción general completa del marco de las colecciones de Java, incluida la clase Hashtable.
- Java en pocas palabras de David Flanagan. Este libro proporciona una referencia rápida de las características principales de Java, incluida la clase Hashtable.
- Colecciones y genéricos de Java de Maurice Naftalin y Philip Wadler. Este libro proporciona una guía completa sobre genéricos y colecciones en Java, incluida la clase Hashtable.
Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html