IL Tabella hash La classe implementa una tabella hash che associa le chiavi ai valori. Qualsiasi oggetto non nullo può essere utilizzato come chiave o come valore. Per archiviare e recuperare correttamente gli oggetti da una tabella hash, gli oggetti utilizzati come chiavi devono implementare il metodo hashCode e il metodo equals.
La classe java.util.Hashtable è una classe in Java che fornisce una struttura dati chiave-valore, simile all'interfaccia Map. Faceva parte del framework Java Collections originale ed è stato introdotto in Java 1.0.
Tuttavia, da allora la classe Hashtable è stata considerata obsoleta e il suo utilizzo è generalmente scoraggiato. Questo perché è stato progettato prima dell'introduzione del framework Collections e non implementa l'interfaccia Map, il che ne rende difficile l'utilizzo insieme ad altre parti del framework. Inoltre, la classe Hashtable è sincronizzata, il che può comportare prestazioni più lente rispetto ad altre implementazioni dell'interfaccia Map.
In generale, si consiglia di utilizzare l'interfaccia Map o una delle sue implementazioni (come HashMap o ConcurrentHashMap) invece della classe Hashtable.
Ecco un esempio di come utilizzare la classe Hashtable:
Giava
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));> >}> >}> }> |
>
>Produzione
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
In conclusione, sebbene la classe Hashtable esista ancora in Java e possa ancora essere utilizzata, in genere è consigliabile utilizzare invece l'interfaccia Map o una delle sue implementazioni.
Caratteristiche di Hashtable
- È simile a HashMap, ma è sincronizzato.
- Hashtable memorizza la coppia chiave/valore nella tabella hash.
- In Hashtable specifichiamo un oggetto che viene utilizzato come chiave e il valore che vogliamo associare a quella chiave. La chiave viene quindi sottoposta ad hashing e il codice hash risultante viene utilizzato come indice in cui il valore viene archiviato all'interno della tabella.
- La capacità predefinita iniziale della classe Hashtable è 11 mentre loadFactor è 0,75.
- HashMap non fornisce alcuna enumerazione, mentre Hashtable fornisce un'enumerazione non fail-fast.
Dichiarazione:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Tipo Parametri:
- K – il tipo di chiavi gestite da questa mappa
- IN – il tipo di valori mappati
La gerarchia di Hashtable
Implementazioni Hashtable Serializzabile , Clonabile , Carta geografica si interfaccia e si estende Dizionario . Le sottoclassi dirette sono Properties , UIDefaults .
Costruttori:
Per creare una Hashtable, dobbiamo importarla da java.util.Hashtable . Esistono vari modi in cui possiamo creare una Hashtable.
1. Tabella hash(): Ciò crea una tabella hash vuota con il fattore di carico predefinito di 0,75 e una capacità iniziale è 11.
Hashtable ht = nuova Hashtable();
Giava
// 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);> >}> }> |
>
>Produzione
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Hashtable(int capacità iniziale): Ciò crea una tabella hash con una dimensione iniziale specificata da partialCapacity e il fattore di carico predefinito è 0,75.
Hashtable ht = new Hashtable(int inizialeCapacità);
come faccio a sapere la dimensione del mio monitor?
Giava
// 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);> >}> }> |
>
>Produzione
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Hashtable (dimensione int, rapporto di riempimento float): Questa versione crea una tabella hash con una dimensione iniziale specificata da size e un rapporto di riempimento specificato da fillRatio. rapporto di riempimento: sostanzialmente, determina quanto può essere piena una tabella hash prima che venga ridimensionata verso l'alto e il suo valore è compreso tra 0,0 e 1,0.
Hashtable ht = new Hashtable(int size, float fillRatio);
Giava
// 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);> >}> }> |
>
>Produzione
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Tabella hash (Mappa m): Questo crea una tabella hash inizializzata con gli elementi in m.
Hashtable ht = nuova Hashtable(Mappa m);
Giava
esegui in PowerShell
// 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);> >}> }> |
>
>Produzione
Mappings of ht2 : {3=three, 2=two, 1=one}> Esempio:
Giava
// 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);> >}> >}> }> |
>
>Produzione
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Esecuzione di varie operazioni su Hashtable
1. Aggiunta di elementi: Per aggiungere un elemento alla tabella hash possiamo utilizzare il metodo put(). Tuttavia, l'ordine di inserimento non viene mantenuto nella tabella hash. Internamente, per ogni elemento, viene generato un hash separato e gli elementi vengono indicizzati in base a questo hash per renderlo più efficiente.
Giava
// 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);> >}> }> |
>
>Produzione
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Modifica degli elementi: Dopo aver aggiunto gli elementi, se desideriamo modificare l'elemento, è possibile farlo aggiungendo nuovamente l'elemento con il metodo put(). Poiché gli elementi della hashtable vengono indicizzati utilizzando le chiavi, è possibile modificare il valore della chiave semplicemente inserendo il valore aggiornato della chiave che si desidera modificare.
Giava
// 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);> >}> }> |
>
>Produzione
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Rimozione dell'elemento: Per rimuovere un elemento dalla Mappa possiamo utilizzare il metodoremove(). Questo metodo prende il valore della chiave e rimuove la mappatura per una chiave da questa mappa se è presente nella mappa.
Giava
// 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);> >}> }> |
>
>Produzione
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Attraversamento di una tabella hash: Per iterare la tabella, possiamo utilizzare an ciclo for avanzato . Di seguito è riportato l'esempio di iterazione di una tabella hash.
Giava
// 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());> >}> }> |
>
>Produzione
pitone __dict__
vaibhav 20 vishal 10 sachin 30>
Funzionamento interno di Hashtable
La struttura dati Hashtable è un array di bucket in cui sono archiviate le coppie chiave/valore. Si avvale di metodo hashCode() per determinare quale bucket deve mappare la coppia chiave/valore.
La funzione hash aiuta a determinare la posizione di una determinata chiave nell'elenco dei desideri. Generalmente, hashcode è un numero intero non negativo che è uguale per oggetti uguali e può o meno essere uguale per oggetti diversi. Per determinare se due oggetti sono uguali o meno, hashtable utilizza il metodo equals().
È possibile che due oggetti non uguali abbiano lo stesso hashcode. Questo è chiamato a collisione . Per risolvere le collisioni, hashtable utilizza una serie di elenchi. Le coppie mappate su un singolo bucket (indice dell'array) vengono archiviate in un elenco e il riferimento all'elenco viene archiviato nell'indice dell'array.
Metodi di Hashtable
- K – Il tipo delle chiavi nella mappa.
- IN – Il tipo di valori mappati nella mappa.
| METODO | DESCRIZIONE |
|---|---|
| chiaro() | Cancella questa tabella hash in modo che non contenga chiavi. |
| clone() | Crea una copia superficiale di questa tabella hash. |
| calcolo (tasto K, BiFunzione K,? super V,? estende V> remappingFunction) | Tenta di calcolare una mappatura per la chiave specificata e il relativo valore mappato corrente (o null se non è presente alcuna mappatura corrente). |
| computeIfAbsent(tasto K, funzione estende V> mappingFunction) | Se la chiave specificata non è già associata a un valore (o è mappata su null), tenta di calcolarne il valore utilizzando la funzione di mappatura specificata e la inserisce in questa mappa a meno che non sia null. |
| computeIfPresent(tasto K, funzione di rimappatura BiFunzione) | Se il valore per la chiave specificata è presente e non nullo, tenta di calcolare una nuova mappatura in base alla chiave e al relativo valore mappato corrente. |
| contiene(valore oggetto) | Verifica se alcune chiavi corrispondono al valore specificato in questa tabella hash. |
| contieneChiave(Chiave oggetto) | Verifica se l'oggetto specificato è una chiave in questa tabella hash. |
| contieneValore(Valore oggetto) | Restituisce vero se questa tabella hash associa una o più chiavi a questo valore. |
| elementi() | Restituisce un'enumerazione dei valori in questa tabella hash. |
| set di voci() | Restituisce una vista Set delle mappature contenute in questa mappa. |
| uguale(Oggetto o) | Confronta l'oggetto specificato con questa mappa per verificarne l'uguaglianza, secondo la definizione nell'interfaccia della mappa. |
| get(Chiave oggetto) | Restituisce il valore a cui è mappata la chiave specificata oppure null se questa mappa non contiene alcuna mappatura per la chiave. |
| codice hash() | Restituisce il valore del codice hash per questa mappa secondo la definizione nell'interfaccia della mappa. |
| è vuoto() | Verifica se questa tabella hash non associa chiavi a valori. |
| chiavi() | Restituisce un'enumerazione delle chiavi in questa tabella hash. |
| mazzo di chiavi() | Restituisce una vista Set delle chiavi contenute in questa mappa. |
| unisci (tasto K, valore V, funzione di rimappatura BiFunzione) | Se la chiave specificata non è già associata a un valore o è associata a null, la associa al valore non null specificato. |
| put(chiave K, valore V) | Mappa la chiave specificata sul valore specificato in questa tabella hash. |
| putAll(Mappa t) | Copia tutte le mappature dalla mappa specificata a questa tabella hash. |
| rimaneggiamento() | Aumenta la capacità e riorganizza internamente questa tabella hash, per accogliere e accedere alle sue voci in modo più efficiente. |
| rimuovi(chiave oggetto) | Rimuove la chiave (e il suo valore corrispondente) da questa tabella hash. |
| misurare() | Restituisce il numero di chiavi in questa tabella hash. |
| accordare() | Restituisce una rappresentazione stringa di questo oggetto Hashtable sotto forma di un insieme di voci, racchiuse tra parentesi graffe e separate dai caratteri ASCII (virgola e spazio). |
| valori() | Restituisce una vista Raccolta dei valori contenuti in questa mappa. |
Metodi dichiarati nell'interfaccia java.util.Map
| METODO | DESCRIZIONE |
|---|---|
| forEach(azione BiConsumer) | Esegue l'azione specificata per ogni voce in questa mappa finché tutte le voci non vengono elaborate o l'azione genera un'eccezione. |
| getOrDefault(Chiave oggetto, V defaultValue) | Restituisce il valore a cui è mappata la chiave specificata oppure defaultValue se questa mappa non contiene alcuna mappatura per la chiave. |
| putIfAbsent(chiave K, valore V) | Se la chiave specificata non è già associata a un valore (o è mappata su null) la associa al valore specificato e restituisce null, altrimenti restituisce il valore corrente. |
| rimuovi(chiave oggetto, Valore dell'oggetto) | Rimuove la voce per la chiave specificata solo se è attualmente mappata al valore specificato. |
| sostituisci (chiave K, valore V) | Sostituisce la voce per la chiave specificata solo se è attualmente mappata su un valore. |
| sostituisci (chiave K, V vecchioValore, V nuovoValore) | Sostituisce la voce per la chiave specificata solo se attualmente mappata al valore specificato. |
| sostituisci tutto (funzione BiFunzione) | Sostituisce il valore di ciascuna voce con il risultato dell'invocazione della funzione specificata su quella voce fino a quando tutte le voci non sono state elaborate o la funzione genera un'eccezione. |
Devi leggere:
- Differenze tra HashMap e HashTable in Java
Vantaggi di Hashtable:
- Thread-safe: la classe Hashtable è thread-safe, il che significa che più thread possono accedervi contemporaneamente senza causare il danneggiamento dei dati o altri problemi di sincronizzazione.
- Semplice da usare: la classe Hashtable è semplice da usare e fornisce funzionalità di base della struttura dati chiave-valore, che possono essere utili per casi semplici.
Svantaggi di Hashtable:
- Obsoleto: la classe Hashtable è considerata obsoleta e il suo utilizzo è generalmente sconsigliato. Questo perché è stato progettato prima dell'introduzione del framework Collections e non implementa l'interfaccia Map, il che ne rende difficile l'utilizzo insieme ad altre parti del framework.
- Funzionalità limitate: la classe Hashtable fornisce funzionalità di base della struttura dati chiave-valore, ma non fornisce la gamma completa di funzionalità disponibili nell'interfaccia Map e nelle sue implementazioni.
- Prestazioni scarse: la classe Hashtable è sincronizzata, il che può comportare prestazioni più lente rispetto ad altre implementazioni dell'interfaccia Map, come HashMap o ConcurrentHashMap.
Libri di riferimento:
- Collezioni Java di Maurice Naftalin e Philip Wadler. Questo libro fornisce una panoramica completa del framework Java Collections, inclusa la classe Hashtable.
- Java in poche parole di David Flanagan. Questo libro fornisce un rapido riferimento alle funzionalità principali di Java, inclusa la classe Hashtable.
- Java Generics e raccolte di Maurice Naftalin e Philip Wadler. Questo libro fornisce una guida completa ai generici e alle raccolte in Java, inclusa la classe Hashtable.
Riferimento: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html