Det Hastbar klasse implementerer en hash-tabel, som kortlægger nøgler til værdier. Ethvert ikke-nul objekt kan bruges som en nøgle eller som en værdi. For at kunne gemme og hente objekter fra en hashtabel, skal de objekter, der bruges som nøgler, implementere hashCode-metoden og equals-metoden.
java.util.Hashtable-klassen er en klasse i Java, der giver en nøgleværdi-datastruktur, der ligner Map-grænsefladen. Det var en del af den originale Java Collections-ramme og blev introduceret i Java 1.0.
Imidlertid er Hashtable-klassen siden blevet betragtet som forældet, og brugen af den frarådes generelt. Dette skyldes, at det blev designet før introduktionen af samlingsrammerne og ikke implementerer kortgrænsefladen, hvilket gør det vanskeligt at bruge i forbindelse med andre dele af rammeværket. Derudover er Hashtable-klassen synkroniseret, hvilket kan resultere i langsommere ydeevne sammenlignet med andre implementeringer af Map-grænsefladen.
Generelt anbefales det at bruge kortgrænsefladen eller en af dens implementeringer (såsom HashMap eller ConcurrentHashMap) i stedet for Hashtable-klassen.
Her er et eksempel på, hvordan du bruger Hashtable-klassen:
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));> >}> >}> }> |
>
>Produktion
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Som konklusion, mens Hashtable-klassen stadig eksisterer i Java og stadig kan bruges, anbefales det generelt at bruge kortgrænsefladen eller en af dens implementeringer i stedet.
Funktioner i Hashtable
- Det ligner HashMap, men er synkroniseret.
- Hashtable gemmer nøgle/værdi-par i hash-tabel.
- I Hashtable angiver vi et objekt, der bruges som en nøgle, og den værdi, vi ønsker at knytte til denne nøgle. Nøglen hashes derefter, og den resulterende hash-kode bruges som det indeks, hvor værdien er gemt i tabellen.
- Den oprindelige standardkapacitet for Hashtable-klassen er 11, mens loadFactor er 0,75.
- HashMap giver ikke nogen optælling, mens Hashtable giver ikke fejl-hurtig optælling.
Erklæring:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Type parametre:
- K – typen af nøgler, der vedligeholdes af dette kort
- I – typen af kortlagte værdier
Hierarki af Hashtable
Hastbare redskaber Serialiserbar , Kan klones , Kort grænseflader og udvider Ordbog . De direkte underklasser er Egenskaber, UID-standarder .
Konstruktører:
For at oprette en hashtabel skal vi importere den fra java.util.Hashtable . Der er forskellige måder, hvorpå vi kan oprette en hashtabel.
1. Hastabel(): Dette skaber en tom hashtabel med standardbelastningsfaktoren på 0,75 og en initial kapacitet er 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);> >}> }> |
>
>Produktion
postordre krydsning
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Hashtable (int initialCapacity): Dette opretter en hash-tabel, der har en startstørrelse angivet af initialCapacity, og standardbelastningsfaktoren er 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);> >}> }> |
>
>Produktion
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Hashtabel (int-størrelse, float fillRatio): Denne version opretter en hash-tabel, der har en startstørrelse angivet efter størrelse og fyldforhold angivet af fillRatio. Fyldforhold: Grundlæggende bestemmer det, hvor fuld en hash-tabel kan være, før den ændres opad, og dens værdi ligger mellem 0,0 til 1,0.
Hashtable ht = new Hashtable(int size, 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);> >}> }> |
>
>Produktion
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Hashtabel (Kort m): Dette skaber en hash-tabel, der initialiseres med elementerne i m.
Hashtabel ht = ny Hashtabel(Kort m);
Java
linux kørselskommando
// 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);> >}> }> |
>
>Produktion
Mappings of ht2 : {3=three, 2=two, 1=one}> Eksempel:
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);> >}> >}> }> |
>
>Produktion
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Udførelse af forskellige operationer på Hashtable
1. Tilføjelse af elementer: For at tilføje et element til hashtabellen kan vi bruge put() metoden. Indsættelsesrækkefølgen bibeholdes dog ikke i hashtabellen. Internt genereres der for hvert element en separat hash, og elementerne indekseres baseret på denne hash for at gøre den mere effektiv.
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);> >}> }> |
>
>Produktion
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Ændring af elementer: Efter tilføjelse af elementerne, hvis vi ønsker at ændre elementet, kan det gøres ved igen at tilføje elementet med put() metoden. Da elementerne i hashtabellen indekseres ved hjælp af nøglerne, kan nøglens værdi ændres ved blot at indsætte den opdaterede værdi for den nøgle, som vi ønsker at ændre.
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);> >}> }> |
>
>Produktion
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Fjernelse af element: For at fjerne et element fra kortet kan vi bruge metoden remove(). Denne metode tager nøgleværdien og fjerner tilknytningen for en nøgle fra dette kort, hvis den er til stede på kortet.
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);> >}> }> |
>
>Produktion
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Gennemgang af en hashtabel: For at iterere tabellen kan vi gøre brug af en avanceret til loop . Nedenfor er eksemplet på iteration af en 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());> >}> }> |
>
>Produktion
sanjay dutt og
vaibhav 20 vishal 10 sachin 30>
Intern drift af hashable
Hashtable datastruktur er en række af buckets, som gemmer nøgle/værdi-parrene i dem. Det gør brug af hashCode() metode for at bestemme, hvilken bucket nøgle/værdi-parret skal kortlægge.
Hash-funktionen hjælper med at bestemme placeringen for en given nøgle i bucket-listen. Generelt er hashkode et ikke-negativt heltal, der er ens for lige objekter og kan være ens for ulige objekter. For at afgøre, om to objekter er ens eller ej, gør hashable brug af equals()-metoden.
Det er muligt, at to ulige objekter har den samme hashkode. Dette kaldes en kollision . For at løse kollisioner bruger hashable en række lister. Parrene, der er knyttet til en enkelt bucket (array-indeks), gemmes i en liste, og listereference gemmes i array-indekset.
Metoder til hashable
- K – Typen af tasterne på kortet.
- I – Typen af værdier, der er kortlagt på kortet.
| METODE | BESKRIVELSE |
|---|---|
| klar() | Rydder denne hashtabel, så den ikke indeholder nogen nøgler. |
| klone() | Opretter en overfladisk kopi af denne hashtabel. |
| compute(K-tast, BiFunction K,? super V,? udvider V> remappingFunction) | Forsøg på at beregne en mapping for den angivne nøgle og dens aktuelle kortlagte værdi (eller null, hvis der ikke er nogen aktuel mapping). |
| computeIfAbsent(K-tast, funktion udvider V> mappingFunction) | Hvis den angivne nøgle ikke allerede er knyttet til en værdi (eller er afbildet til null), forsøger du at beregne dens værdi ved hjælp af den givne tilknytningsfunktion og indtaster den i dette kort, medmindre null. |
| computeIfPresent(K-nøgle, BiFunction remappingFunction) | Hvis værdien for den angivne nøgle er til stede og ikke er nul, forsøger man at beregne en ny mapping givet nøglen og dens aktuelle tilknyttede værdi. |
| indeholder (objektværdi) | Tester om nogle nøgler er knyttet til den angivne værdi i denne hashtabel. |
| containsKey(Objektnøgle) | Tester om det angivne objekt er en nøgle i denne hashtabel. |
| indeholderVærdi(objektværdi) | Returnerer sand, hvis denne hashtabel knytter en eller flere nøgler til denne værdi. |
| elementer() | Returnerer en opregning af værdierne i denne hashtabel. |
| entrySet() | Returnerer en Set-visning af kortlægningerne på dette kort. |
| er lig med (Objekt o) | Sammenligner det angivne objekt med dette kort for lighed i henhold til definitionen i kortgrænsefladen. |
| get (objektnøgle) | Returnerer den værdi, som den angivne nøgle er knyttet til, eller null, hvis dette kort ikke indeholder nogen tilknytning til nøglen. |
| hashCode() | Returnerer hash-kodeværdien for dette kort i henhold til definitionen i kortgrænsefladen. |
| er tom() | Tester, om denne hashtabel ikke tilordner nøgler til værdier. |
| nøgler() | Returnerer en opregning af nøglerne i denne hashtabel. |
| keySet() | Returnerer en Set-visning af nøglerne på dette kort. |
| flet (K-nøgle, V-værdi, BiFunction remappingFunction) | Hvis den angivne nøgle ikke allerede er knyttet til en værdi eller er knyttet til null, knytter den til den givne ikke-nullværdi. |
| put (K-tast, V-værdi) | Knytter den angivne nøgle til den angivne værdi i denne hashtabel. |
| putAll(Map t) | Kopierer alle tilknytninger fra det angivne kort til denne hashtabel. |
| rehash() | Øger kapaciteten af og internt omorganiserer denne hashable for at imødekomme og få adgang til dens poster mere effektivt. |
| fjern (objektnøgle) | Fjerner nøglen (og dens tilsvarende værdi) fra denne hashtabel. |
| størrelse() | Returnerer antallet af nøgler i denne hashtabel. |
| toString() | Returnerer en strengrepræsentation af dette Hashtable-objekt i form af et sæt indgange, omgivet af klammer og adskilt af ASCII-tegnene , (komma og mellemrum). |
| værdier() | Returnerer en samlingsvisning af værdierne på dette kort. |
Metoder erklæret i interface java.util.Map
| METODE | BESKRIVELSE |
|---|---|
| forEach(BiConsumer action) | Udfører den givne handling for hver post i dette kort, indtil alle poster er blevet behandlet, eller handlingen giver en undtagelse. |
| getOrDefault(Objektnøgle, V defaultValue) | Returnerer den værdi, som den angivne nøgle er knyttet til, eller standardværdi, hvis dette kort ikke indeholder nogen tilknytning til nøglen. |
| putIfAbsent(K-nøgle, V-værdi) | Hvis den angivne nøgle ikke allerede er knyttet til en værdi (eller er knyttet til null), associerer den med den givne værdi og returnerer null, ellers returnerer den aktuelle værdi. |
| fjern (Objektnøgle, Objektværdi) | Fjerner kun posten for den angivne nøgle, hvis den i øjeblikket er knyttet til den angivne værdi. |
| erstatte (K-tast, V-værdi) | Erstatter kun indgangen for den angivne nøgle, hvis den i øjeblikket er knyttet til en eller anden værdi. |
| erstat (K-tast, V oldValue, V newValue) | Erstatter kun indgangen for den angivne nøgle, hvis den i øjeblikket er knyttet til den angivne værdi. |
| replaceAll (BiFunction funktion) | Erstatter hver posts værdi med resultatet af at kalde den givne funktion på den post, indtil alle poster er blevet behandlet, eller funktionen kaster en undtagelse. |
Skal læses:
- Forskelle mellem HashMap og HashTable i Java
Fordele ved Hashtable:
- Trådsikker: Hashtable-klassen er trådsikker, hvilket betyder, at flere tråde kan få adgang til den samtidigt uden at forårsage datakorruption eller andre synkroniseringsproblemer.
- Enkel at bruge: Hashtable-klassen er enkel at bruge og giver grundlæggende nøgleværdi-datastrukturfunktionalitet, som kan være nyttig til simple tilfælde.
Ulemper ved hashable:
- Forældet: Hashtable-klassen anses for at være forældet, og brugen af den frarådes generelt. Dette skyldes, at det blev designet før introduktionen af samlingsrammerne og ikke implementerer kortgrænsefladen, hvilket gør det vanskeligt at bruge i forbindelse med andre dele af rammeværket.
- Begrænset funktionalitet: Hashtable-klassen giver grundlæggende nøgleværdi-datastrukturfunktionalitet, men giver ikke hele rækken af funktionalitet, der er tilgængelig i kortgrænsefladen og dens implementeringer.
- Dårlig ydeevne: Hashtable-klassen er synkroniseret, hvilket kan resultere i langsommere ydeevne sammenlignet med andre implementeringer af kortgrænsefladen, såsom HashMap eller ConcurrentHashMap.
Opslagsbøger:
- Java-samlinger af Maurice Naftalin og Philip Wadler. Denne bog giver et omfattende overblik over Java Collections-rammerne, inklusive Hashtable-klassen.
- Java i en nøddeskal af David Flanagan. Denne bog giver en hurtig reference til kernefunktionerne i Java, inklusive Hashtable-klassen.
- Java Generics and Collections af Maurice Naftalin og Philip Wadler. Denne bog giver en omfattende guide til generiske artikler og samlinger i Java, inklusive Hashtable-klassen.
Reference: https://docs.oracle.com/da/java/javase/11/docs/api/java.base/java/util/Hashtable.html