De Hashtabel class implementeert een hashtabel, die sleutels aan waarden toewijst. Elk niet-null-object kan als sleutel of als waarde worden gebruikt. Om objecten met succes uit een hashtabel op te slaan en op te halen, moeten de objecten die als sleutels worden gebruikt de hashCode-methode en de equals-methode implementeren.
De klasse java.util.Hashtable is een klasse in Java die een sleutel-waardegegevensstructuur biedt, vergelijkbaar met de Map-interface. Het maakte deel uit van het oorspronkelijke Java Collections-framework en werd geïntroduceerd in Java 1.0.
De klasse Hashtable wordt sindsdien echter als verouderd beschouwd en het gebruik ervan wordt over het algemeen afgeraden. Dit komt omdat het is ontworpen vóór de introductie van het Collections-framework en de Map-interface niet implementeert, waardoor het moeilijk te gebruiken is in combinatie met andere delen van het framework. Bovendien wordt de Hashtable-klasse gesynchroniseerd, wat kan resulteren in langzamere prestaties in vergelijking met andere implementaties van de Map-interface.
Over het algemeen wordt aanbevolen om de Map-interface of een van de implementaties ervan (zoals HashMap of ConcurrentHashMap) te gebruiken in plaats van de Hashtable-klasse.
Hier is een voorbeeld van hoe u de Hashtable-klasse gebruikt:
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));> >}> >}> }> |
>
>Uitvoer
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Concluderend: hoewel de Hashtable-klasse nog steeds bestaat in Java en nog steeds kan worden gebruikt, wordt het over het algemeen aanbevolen om in plaats daarvan de Map-interface of een van de implementaties ervan te gebruiken.
Kenmerken van Hashtable
- Het is vergelijkbaar met HashMap, maar is gesynchroniseerd.
- Hashtable slaat sleutel/waarde-paar op in hashtabel.
- In Hashtable specificeren we een object dat als sleutel wordt gebruikt, en de waarde die we aan die sleutel willen koppelen. De sleutel wordt vervolgens gehasht en de resulterende hashcode wordt gebruikt als de index waarop de waarde in de tabel wordt opgeslagen.
- De initiële standaardcapaciteit van de Hashtable-klasse is 11, terwijl de loadFactor 0,75 is.
- HashMap biedt geen opsomming, terwijl Hashtable geen feilloze opsomming biedt.
Verklaring:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Typeparameters:
- K – het type sleutels dat door deze kaart wordt onderhouden
- IN – het type toegewezen waarden
De hiërarchie van hashtabel
Hashtable-werktuigen Serialiseerbaar , Kloonbaar , Kaart raakvlakken en breidt uit Woordenboek . De directe subklassen zijn Properties , UID-fouten .
Constructeurs:
Om een hashtabel te maken, moeten we deze importeren uit java.util.Hashtabel . Er zijn verschillende manieren waarop we een hashtabel kunnen maken.
1. Hashtabel(): Hierdoor ontstaat een lege hashtabel met de standaardbeladingsfactor van 0,75 en een initiële capaciteit van 11.
Hashtabel ht = nieuwe Hashtabel();
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);> >}> }> |
>
>Uitvoer
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Hashtabel (int initiële capaciteit): Hierdoor wordt een hashtabel gemaakt met een initiële grootte die is opgegeven door initialCapacity en de standaardbelastingsfactor is 0,75.
Hashtabel ht = nieuwe Hashtabel (int initiëleCapaciteit);
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);> >}> }> |
>
>Uitvoer
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Hashtabel (int-grootte, float fillRatio): Deze versie maakt een hashtabel met een initiële grootte die wordt gespecificeerd door de grootte en de vulverhouding gespecificeerd door fillRatio. vulratio: Kortom, het bepaalt hoe vol een hashtabel kan zijn voordat deze naar boven wordt vergroot en de waarde tussen 0,0 en 1,0 ligt.
Hashtabel ht = nieuwe Hashtabel (int-grootte, float fillRatio);
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);> >}> }> |
>
>Uitvoer
int naar string c++
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Hashtabel (kaart m): Hierdoor ontstaat een hashtabel die wordt geïnitialiseerd met de elementen in m.
Hashtabel ht = nieuwe Hashtabel (kaart 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);> >}> }> |
>
>Uitvoer
Mappings of ht2 : {3=three, 2=two, 1=one}> Voorbeeld:
Java
Java-vergelijkingsreeksen
// 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);> >}> >}> }> |
>
>Uitvoer
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Verschillende bewerkingen uitvoeren op Hashtable
1. Elementen toevoegen: Om een element aan de hashtabel toe te voegen, kunnen we de methode put() gebruiken. De invoegvolgorde wordt echter niet bewaard in de hashtabel. Intern wordt voor elk element een aparte hash gegenereerd en op basis van deze hash worden de elementen geïndexeerd om het efficiënter te maken.
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);> >}> }> |
>
>Uitvoer
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Elementen veranderen: Als we na het toevoegen van de elementen het element willen wijzigen, kan dit worden gedaan door het element opnieuw toe te voegen met de put() methode. Omdat de elementen in de hashtabel worden geïndexeerd met behulp van de sleutels, kan de waarde van de sleutel worden gewijzigd door eenvoudigweg de bijgewerkte waarde in te voegen voor de sleutel waarvoor we deze willen wijzigen.
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);> >}> }> |
>
>Uitvoer
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Element verwijderen: Om een element uit de kaart te verwijderen, kunnen we de methode remove() gebruiken. Deze methode neemt de sleutelwaarde en verwijdert de toewijzing voor een sleutel uit deze kaart als deze aanwezig is op de kaart.
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);> >}> }> |
>
>Uitvoer
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Doorloop van een hashtabel: Om de tabel te herhalen, kunnen we gebruik maken van een geavanceerd voor lus . Hieronder ziet u een voorbeeld van het herhalen van een hashtabel.
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());> >}> }> |
>
>Uitvoer
vaibhav 20 vishal 10 sachin 30>
Interne werking van hashtabel
Hashtable-datastructuur is een array van buckets waarin de sleutel/waarde-paren zijn opgeslagen. Het maakt gebruik van hashCode()-methode om te bepalen welke bucket het sleutel/waarde-paar moet toewijzen.
De hashfunctie helpt bij het bepalen van de locatie van een bepaalde sleutel in de bucketlist. Over het algemeen is hashcode een niet-negatief geheel getal dat gelijk is voor gelijke objecten en al dan niet gelijk is voor ongelijke objecten. Om te bepalen of twee objecten gelijk zijn of niet, maakt hashtable gebruik van de equals() methode.
Het is mogelijk dat twee ongelijke objecten dezelfde hashcode hebben. Dit heet een botsing . Om botsingen op te lossen, gebruikt hashtable een reeks lijsten. De paren die zijn toegewezen aan een enkele bucket (array-index) worden opgeslagen in een lijst en de lijstverwijzing wordt opgeslagen in de array-index.
Methoden van hashtabel
- K – Het type sleutels op de kaart.
- IN – Het type waarden dat op de kaart in kaart is gebracht.
| METHODE | BESCHRIJVING |
|---|---|
| duidelijk() | Wist deze hashtabel zodat deze geen sleutels bevat. |
| kloon() | Creëert een ondiepe kopie van deze hashtabel. |
| berekenen(K-toets, BiFunction K,? superV,? breidt V> remappingFunction uit) | Probeert een toewijzing te berekenen voor de opgegeven sleutel en de huidige toegewezen waarde (of null als er geen huidige toewijzing is). |
| computeIfAbsent(K-toets, Function breidt V> mappingFunctie uit) | Als de opgegeven sleutel nog niet aan een waarde is gekoppeld (of is toegewezen aan null), wordt geprobeerd de waarde ervan te berekenen met behulp van de gegeven toewijzingsfunctie en deze in deze kaart in te voeren, tenzij null. |
| computeIfPresent(K-sleutel, BiFunction remappingFunction) | Als de waarde voor de opgegeven sleutel aanwezig is en niet nul is, wordt geprobeerd een nieuwe toewijzing te berekenen op basis van de sleutel en de huidige toegewezen waarde. |
| bevat(Objectwaarde) | Test of een bepaalde sleutel overeenkomt met de opgegeven waarde in deze hashtabel. |
| bevatsleutel(Objectsleutel) | Test of het opgegeven object een sleutel is in deze hashtabel. |
| bevatWaarde(Objectwaarde) | Retourneert waar als deze hashtabel een of meer sleutels aan deze waarde toewijst. |
| elementen() | Retourneert een opsomming van de waarden in deze hashtabel. |
| entrySet() | Retourneert een ingestelde weergave van de toewijzingen op deze kaart. |
| is gelijk aan(Object o) | Vergelijkt het opgegeven object met deze kaart op gelijkheid, volgens de definitie in de kaartinterface. |
| get(Objectsleutel) | Retourneert de waarde waaraan de opgegeven sleutel is toegewezen, of null als deze toewijzing geen toewijzing voor de sleutel bevat. |
| hashCode() | Retourneert de hashcodewaarde voor deze kaart volgens de definitie in de kaartinterface. |
| is leeg() | Test of deze hashtabel geen sleutels aan waarden toewijst. |
| sleutels() | Retourneert een opsomming van de sleutels in deze hashtabel. |
| sleutelbos() | Retourneert een ingestelde weergave van de sleutels op deze kaart. |
| merge(K-sleutel, V-waarde, BiFunction remappingFunction) | Als de opgegeven sleutel nog niet aan een waarde is gekoppeld of aan null is gekoppeld, wordt deze aan de opgegeven niet-null-waarde gekoppeld. |
| put(K-sleutel, V-waarde) | Wijst de opgegeven sleutel toe aan de opgegeven waarde in deze hashtabel. |
| putAll(Kaart t) | Kopieert alle toewijzingen van de opgegeven kaart naar deze hashtabel. |
| herhalen() | Vergroot de capaciteit van deze hashtabel en reorganiseert deze intern, om de vermeldingen efficiënter te kunnen huisvesten en openen. |
| verwijderen(Objectsleutel) | Verwijdert de sleutel (en de bijbehorende waarde) uit deze hashtabel. |
| maat() | Retourneert het aantal sleutels in deze hashtabel. |
| toString() | Retourneert een tekenreeksrepresentatie van dit Hashtable-object in de vorm van een reeks vermeldingen, tussen accolades en gescheiden door de ASCII-tekens , (komma en spatie). |
| waarden() | Retourneert een verzamelingsweergave van de waarden in deze kaart. |
Methoden gedeclareerd in interface java.util.Map
| METHODE | BESCHRIJVING |
|---|---|
| forEach(BiConsumer-actie) | Voert de gegeven actie uit voor elk item op deze kaart totdat alle items zijn verwerkt of de actie een uitzondering genereert. |
| getOrDefault(Objectsleutel, V standaardwaarde) | Retourneert de waarde waaraan de opgegeven sleutel is toegewezen, of defaultValue als deze toewijzing geen toewijzing voor de sleutel bevat. |
| putIfAbsent(K-sleutel, V-waarde) | Als de opgegeven sleutel nog niet aan een waarde is gekoppeld (of is toegewezen aan null), wordt deze aan de opgegeven waarde gekoppeld en wordt null geretourneerd, anders wordt de huidige waarde geretourneerd. |
| verwijderen(Objecttoets, Objectwaarde) | Verwijdert de vermelding voor de opgegeven sleutel alleen als deze momenteel is toegewezen aan de opgegeven waarde. |
| vervangen (K-sleutel, V-waarde) | Vervangt de vermelding voor de opgegeven sleutel alleen als deze momenteel aan een bepaalde waarde is toegewezen. |
| vervangen(K-sleutel, V oudeWaarde, V nieuweWaarde) | Vervangt de vermelding voor de opgegeven sleutel alleen als deze momenteel is toegewezen aan de opgegeven waarde. |
| ReplaceAll (BiFunctie-functie) | Vervangt de waarde van elk item door het resultaat van het aanroepen van de gegeven functie voor dat item totdat alle items zijn verwerkt of de functie een uitzondering genereert. |
Moet lezen:
- Verschillen tussen HashMap en HashTable in Java
Voordelen van Hashtabel:
- Thread-safe: De Hashtable-klasse is thread-safe, wat betekent dat meerdere threads er tegelijkertijd toegang toe hebben zonder gegevensbeschadiging of andere synchronisatieproblemen te veroorzaken.
- Eenvoudig te gebruiken: De Hashtable-klasse is eenvoudig te gebruiken en biedt basisfunctionaliteit voor de sleutel-waardegegevensstructuur, wat handig kan zijn voor eenvoudige gevallen.
Nadelen van Hashtable:
- Verouderd: De Hashtable-klasse wordt als verouderd beschouwd en het gebruik ervan wordt over het algemeen afgeraden. Dit komt omdat het is ontworpen vóór de introductie van het Collections-framework en de Map-interface niet implementeert, waardoor het moeilijk te gebruiken is in combinatie met andere delen van het framework.
- Beperkte functionaliteit: De Hashtable-klasse biedt basisfunctionaliteit voor de sleutel-waardedatastructuur, maar biedt niet het volledige scala aan functionaliteit dat beschikbaar is in de Map-interface en de implementaties ervan.
- Slechte prestaties: de Hashtable-klasse is gesynchroniseerd, wat kan resulteren in langzamere prestaties in vergelijking met andere implementaties van de Map-interface, zoals HashMap of ConcurrentHashMap.
Naslagwerken:
- Java-collecties van Maurice Naftalin en Philip Wadler. Dit boek biedt een uitgebreid overzicht van het Java Collections-framework, inclusief de Hashtable-klasse.
- Java in een notendop door David Flanagan. Dit boek biedt een snelle referentie voor de kernfuncties van Java, inclusief de Hashtable-klasse.
- Java-generieken en collecties door Maurice Naftalin en Philip Wadler. Dit boek biedt een uitgebreide handleiding voor generieke geneesmiddelen en collecties in Java, inclusief de Hashtable-klasse.
Referentie: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html