El Taula hash class implementa una taula hash, que mapeja les claus amb els valors. Qualsevol objecte no nul es pot utilitzar com a clau o com a valor. Per emmagatzemar i recuperar objectes d'una taula hash amb èxit, els objectes utilitzats com a claus han d'implementar el mètode hashCode i el mètode equals.
La classe java.util.Hashtable és una classe de Java que proporciona una estructura de dades clau-valor, similar a la interfície Map. Formava part del marc original de Java Collections i es va introduir a Java 1.0.
No obstant això, la classe Hashtable s'ha considerat obsoleta des d'aleshores i generalment es desaconsella el seu ús. Això es deu al fet que es va dissenyar abans de la introducció del marc de col·leccions i no implementa la interfície Map, cosa que dificulta l'ús conjuntament amb altres parts del marc. A més, la classe Hashtable està sincronitzada, cosa que pot provocar un rendiment més lent en comparació amb altres implementacions de la interfície Map.
En general, es recomana utilitzar la interfície Map o una de les seves implementacions (com ara HashMap o ConcurrentHashMap) en lloc de la classe Hashtable.
Aquí teniu un exemple de com utilitzar la classe Hashtable:
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));> >}> >}> }> |
funció de subcadena de Java
>
>Sortida
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
En conclusió, tot i que la classe Hashtable encara existeix a Java i encara es pot utilitzar, generalment es recomana utilitzar la interfície Map o una de les seves implementacions.
Característiques de Hashtable
- És similar a HashMap, però està sincronitzat.
- La taula hash emmagatzema el parell clau/valor a la taula hash.
- A Hashtable especifiquem un objecte que s'utilitza com a clau i el valor que volem associar a aquesta clau. Aleshores, la clau s'estén i el codi hash resultant s'utilitza com a índex on s'emmagatzema el valor dins de la taula.
- La capacitat inicial per defecte de la classe Hashtable és 11 mentre que loadFactor és 0,75.
- HashMap no proporciona cap enumeració, mentre que Hashtable no proporciona una enumeració ràpida.
Declaració:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Paràmetres de tipus:
- K – el tipus de claus que manté aquest mapa
- EN – el tipus de valors assignats
La jerarquia de Hashtable
Implements de hashtable Serialitzable , Clonable , Mapa interfícies i s'estén Diccionari . Les subclasses directes són Propietats, UIDefaults .
Constructors:
Per crear una taula hash, hem d'importar-la des de java.util.Hashtable . Hi ha diverses maneres en què podem crear una taula hash.
1. Taula hash(): Això crea una taula hash buida amb el factor de càrrega predeterminat de 0,75 i una capacitat inicial és 11.
Hashtable ht = new 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);> >}> }> |
>
>Sortida
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Taula hash (int initialCapacity): Això crea una taula hash que té una mida inicial especificada per initialCapacity i el factor de càrrega predeterminat és 0,75.
Hashtable ht = new Hashtable(int initialCapacity);
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);> >}> }> |
>
>Sortida
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Taula hash (mida int, float fillRatio): Aquesta versió crea una taula hash que té una mida inicial especificada per la mida i la proporció d'ompliment especificada per fillRatio. proporció d'ompliment: bàsicament, determina fins a quin punt pot estar plena una taula hash abans que es redimensioni cap amunt i el seu valor es troba entre 0,0 i 1,0.
Hashtable ht = new Hashtable (mida int, float fillRatio);
Java
data d'utilitat 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>,>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);> >}> }> |
>
>Sortida
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Taula hash (mapa m): Això crea una taula hash que s'inicialitza amb els elements en m.
Hashtable ht = new 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);> >}> }> |
>
>Sortida
Mappings of ht2 : {3=three, 2=two, 1=one}> Exemple:
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);> >}> >}> }> |
>
>Sortida
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Realització de diverses operacions en Hashtable
1. Afegir elements: Per afegir un element a la taula hash, podem utilitzar el mètode put(). Tanmateix, l'ordre d'inserció no es conserva a la taula hash. Internament, per a cada element, es genera un hash independent i els elements s'indexen en funció d'aquest hash per fer-lo més eficient.
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);> >}> }> |
window.open javascript
>
>Sortida
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Elements canviants: Després d'afegir els elements si volem canviar l'element, es pot fer afegint de nou l'element amb el mètode put(). Com que els elements de la taula hash s'indexen mitjançant les claus, el valor de la clau es pot canviar simplement inserint el valor actualitzat de la clau per a la qual volem canviar.
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);> >}> }> |
>
>Sortida
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Eliminació de l'element: Per eliminar un element del mapa, podem utilitzar el mètode remove(). Aquest mètode pren el valor de la clau i elimina l'assignació d'una clau d'aquest mapa si està present al 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);> >}> }> |
>
>Sortida
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Travessia d'una taula hash: Per repetir la taula, podem fer servir un bucle for avançat . A continuació es mostra l'exemple d'iteració d'una taula 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());> >}> }> |
>
>Sortida
vaibhav 20 vishal 10 sachin 30>
Funcionament intern de Hashtable
L'estructura de dades hashtable és una matriu de cubs que emmagatzema els parells clau/valor en ells. Fa ús de mètode hashCode(). per determinar quin grup ha de mapar la parella clau/valor.
La funció hash ajuda a determinar la ubicació d'una clau determinada a la llista de cubs. En general, el codi hash és un nombre enter no negatiu que és igual per a objectes iguals i pot ser o no igual per a objectes desiguals. Per determinar si dos objectes són iguals o no, hashtable fa servir el mètode equals().
És possible que dos objectes desiguals tinguin el mateix codi hash. Això s'anomena a col·lisió . Per resoldre col·lisions, hashtable utilitza una matriu de llistes. Els parells assignats a un únic cub (índex de matriu) s'emmagatzemen en una llista i la referència de la llista s'emmagatzema a l'índex de matriu.
Mètodes de Hashtable
- K – El tipus de claus del mapa.
- EN – El tipus de valors assignats al mapa.
| MÈTODE | DESCRIPCIÓ |
|---|---|
| clar () | Esborra aquesta taula hash perquè no contingui cap clau. |
| clonar () | Crea una còpia superficial d'aquesta taula hash. |
| calcular (tecla K, BiFunction K,? super V,? amplia V> reasignació de la funció) | Intenta calcular una assignació per a la clau especificada i el seu valor assignat actual (o nul si no hi ha cap assignació actual). |
| computeIfAbsent (tecla K, funció amplia V> mappingFunction) | Si la clau especificada encara no està associada amb un valor (o està assignada a null), prova de calcular-ne el valor mitjançant la funció de mapeig donada i l'introdueix en aquest mapa tret que sigui nul. |
| computeIfPresent (clau K, funció de reasignació de BiFunction) | Si el valor de la clau especificada és present i no és nul, s'intenta calcular una assignació nova donada la clau i el seu valor assignat actual. |
| conté (valor de l'objecte) | Comprova si algunes claus es corresponen amb el valor especificat en aquesta taula hash. |
| containsKey (clau d'objecte) | Comprova si l'objecte especificat és una clau en aquesta taula hash. |
| containsValue (Valor de l'objecte) | Retorna true si aquesta taula hash associa una o més claus a aquest valor. |
| elements () | Retorna una enumeració dels valors d'aquesta taula hash. |
| entrySet() | Retorna una vista conjunta dels mapes continguts en aquest mapa. |
| és igual a (Objecte o) | Compara l'objecte especificat amb aquest mapa per a la igualtat, segons la definició de la interfície del mapa. |
| obtenir (clau d'objecte) | Retorna el valor al qual s'ha assignat la clau especificada o nul si aquest mapa no conté cap assignació per a la clau. |
| hashCode() | Retorna el valor del codi hash per a aquest mapa segons la definició de la interfície del mapa. |
| està buit() | Comprova si aquesta taula hash no mapeja cap clau amb valors. |
| claus() | Retorna una enumeració de les claus d'aquesta taula hash. |
| keySet() | Retorna una vista conjunta de les claus contingudes en aquest mapa. |
| combinar (clau K, valor V, funció de reasignació de BiFunction) | Si la clau especificada encara no està associada amb un valor o està associada amb null, l'associa amb el valor no nul donat. |
| posar (clau K, valor V) | Assigna la clau especificada al valor especificat en aquesta taula hash. |
| putAll(Mapa t) | Copia tots els mapes del mapa especificat a aquesta taula hash. |
| repetir () | Augmenta la capacitat i reorganitza internament aquesta taula hash, per tal d'acomodar i accedir a les seves entrades de manera més eficient. |
| eliminar (clau d'objecte) | Elimina la clau (i el seu valor corresponent) d'aquesta taula hash. |
| mida () | Retorna el nombre de claus d'aquesta taula hash. |
| toString() | Retorna una representació de cadena d'aquest objecte Hashtable en forma d'un conjunt d'entrades, tancades entre claus i separades pels caràcters ASCII , (coma i espai). |
| valors () | Retorna una vista de col·lecció dels valors continguts en aquest mapa. |
Mètodes declarats a la interfície java.util.Map
| MÈTODE | DESCRIPCIÓ git add --all |
|---|---|
| forEach (acció BiConsumidor) | Realitza l'acció donada per a cada entrada d'aquest mapa fins que s'hagin processat totes les entrades o l'acció produeixi una excepció. |
| getOrDefault (clau d'objecte, V defaultValue) | Retorna el valor al qual està assignada la clau especificada, o defaultValue si aquest mapa no conté cap assignació per a la clau. |
| putIfAbsent(clau K, valor V) | Si la clau especificada encara no està associada amb un valor (o està assignada a null) l'associa amb el valor donat i retorna null, en cas contrari retorna el valor actual. |
| eliminar (clau d'objecte, valor de l'objecte) | Elimina l'entrada de la clau especificada només si actualment està assignada al valor especificat. |
| substituir (clau K, valor V) | Substitueix l'entrada de la clau especificada només si actualment està assignada a algun valor. |
| substituir (clau K, V valor antic, V valor nou) | Substitueix l'entrada de la clau especificada només si actualment està assignada al valor especificat. |
| replaceAll (funció BiFunction) | Substitueix el valor de cada entrada amb el resultat d'invocar la funció donada en aquesta entrada fins que s'hagin processat totes les entrades o la funció llança una excepció. |
Cal llegir:
- Diferències entre HashMap i HashTable a Java
Avantatges de Hashtable:
- Seguretat per a fils: la classe Hashtable és segura per a fils, el que significa que diversos fils poden accedir-hi simultàniament sense causar corrupció de dades o altres problemes de sincronització.
- Fàcil d'utilitzar: la classe Hashtable és senzilla d'utilitzar i proporciona una funcionalitat bàsica d'estructura de dades clau-valor, que pot ser útil per a casos senzills.
Desavantatges de Hashtable:
- Obsolet: la classe Hashtable es considera obsoleta i generalment es desaconsella el seu ús. Això es deu al fet que es va dissenyar abans de la introducció del marc de col·leccions i no implementa la interfície Map, cosa que dificulta l'ús conjuntament amb altres parts del marc.
- Funcionalitat limitada: la classe Hashtable proporciona una funcionalitat bàsica de l'estructura de dades clau-valor, però no ofereix la gamma completa de funcionalitats que hi ha disponible a la interfície Map i les seves implementacions.
- Rendiment baix: la classe Hashtable està sincronitzada, la qual cosa pot provocar un rendiment més lent en comparació amb altres implementacions de la interfície Map, com ara HashMap o ConcurrentHashMap.
Llibres de referència:
- Col·leccions Java de Maurice Naftalin i Philip Wadler. Aquest llibre ofereix una visió general completa del marc de col·leccions de Java, inclosa la classe Hashtable.
- Java en poques paraules de David Flanagan. Aquest llibre proporciona una referència ràpida per a les característiques bàsiques de Java, inclosa la classe Hashtable.
- Java Generics and Collections de Maurice Naftalin i Philip Wadler. Aquest llibre ofereix una guia completa sobre genèrics i col·leccions en Java, inclosa la classe Hashtable.
Referència: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html