De Hastbar klasse implementerer en hash-tabell, som kartlegger nøkler til verdier. Ethvert ikke-null objekt kan brukes som en nøkkel eller som en verdi. For å lykkes med å lagre og hente objekter fra en hashtabell, må objektene som brukes som nøkler implementere hashCode-metoden og equals-metoden.
Java.util.Hashtable-klassen er en klasse i Java som gir en nøkkelverdi-datastruktur, lik Map-grensesnittet. Det var en del av det originale Java Collections-rammeverket og ble introdusert i Java 1.0.
Imidlertid har Hashtable-klassen siden blitt ansett som foreldet, og bruken frarådes generelt. Dette er fordi det ble designet før introduksjonen av rammeverket for samlinger og ikke implementerer kartgrensesnittet, noe som gjør det vanskelig å bruke det sammen med andre deler av rammeverket. I tillegg er Hashtable-klassen synkronisert, noe som kan resultere i tregere ytelse sammenlignet med andre implementeringer av Map-grensesnittet.
Generelt anbefales det å bruke kartgrensesnittet eller en av dets implementeringer (som HashMap eller ConcurrentHashMap) i stedet for Hashtable-klassen.
Her er et eksempel på hvordan du bruker 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));> >}> >}> }> |
>
>Produksjon
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Som konklusjon, mens Hashtable-klassen fortsatt eksisterer i Java og fortsatt kan brukes, anbefales det generelt å bruke kartgrensesnittet eller en av implementeringene i stedet.
Funksjoner av Hashtable
- Det ligner på HashMap, men er synkronisert.
- Hashtable lagrer nøkkel/verdi-par i hashtabell.
- I Hashtable spesifiserer vi et objekt som brukes som en nøkkel, og verdien vi ønsker å knytte til den nøkkelen. Nøkkelen hashes deretter, og den resulterende hashkoden brukes som indeksen der verdien lagres i tabellen.
- Den opprinnelige standardkapasiteten til Hashtable-klassen er 11, mens loadFactor er 0,75.
- HashMap gir ingen opptelling, mens Hashtable gir ikke sviktende oppregning.
Erklæring:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Typeparametere:
- K – typen nøkler som vedlikeholdes av dette kartet
- I – typen kartlagte verdier
Hierarkiet til Hashtable
Hastbare redskaper Serialiserbar , Klonbar , Kart grensesnitt og utvider Ordbok . De direkte underklassene er egenskaper, UID-standarder .
Konstruktører:
For å lage en hashtabell må vi importere den fra java.util.Hashtable . Det er forskjellige måter vi kan lage en hashtabell på.
1. Hasttabell(): Dette skaper en tom hashtabell med standard belastningsfaktor på 0,75 og en startkapasitet er 11.
Hasttabell ht = ny hashtabell();
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);> >}> }> |
>
>Produksjon
kø og prioritert kø i java
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Hastabel (int initialCapacity): Dette oppretter en hash-tabell som har en startstørrelse spesifisert av initialCapacity og standard belastningsfaktor 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);> >}> }> |
>
>Produksjon
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Hastbar (int størrelse, flytefyllforhold): Denne versjonen lager en hash-tabell som har en startstørrelse spesifisert etter størrelse og fyllforhold spesifisert av fillRatio. fyllforhold: I utgangspunktet bestemmer den hvor full en hashtabell kan være før den endres oppover og verdien ligger mellom 0,0 og 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);> >}> }> |
>
>Produksjon
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Hasttabell (Kart m): Dette lager en hash-tabell som initialiseres med elementene i m.
Hasttabell ht = ny hashtabell(Kart m);
Java
linux kjøre kommando
// 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);> >}> }> |
>
>Produksjon
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);> >}> >}> }> |
>
>Produksjon
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Utføre forskjellige operasjoner på Hashtable
1. Legge til elementer: For å legge til et element i hashtabellen kan vi bruke put()-metoden. Innsettingsrekkefølgen beholdes imidlertid ikke i hashtabellen. Internt, for hvert element, genereres en separat hash og elementene indekseres basert på denne hashen for å gjøre den mer 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);> >}> }> |
>
>Produksjon
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Endre elementer: Etter å ha lagt til elementene hvis vi ønsker å endre elementet, kan det gjøres ved å legge til elementet igjen med put()-metoden. Siden elementene i hashtabellen er indeksert ved hjelp av nøklene, kan verdien til nøkkelen endres ved ganske enkelt å sette inn den oppdaterte verdien for nøkkelen vi ønsker å endre.
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);> >}> }> |
>
>Produksjon
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Fjerning av element: For å fjerne et element fra kartet, kan vi bruke remove()-metoden. Denne metoden tar nøkkelverdien og fjerner tilordningen for en nøkkel fra dette kartet hvis den finnes i kartet.
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);> >}> }> |
>
>Produksjon
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Traversering av en hashtabell: For å iterere tabellen kan vi benytte oss av en avansert for loop . Nedenfor er eksemplet på iterering av en hashtabell.
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());> >}> }> |
>
>Produksjon
sanjay dutt og
vaibhav 20 vishal 10 sachin 30>
Intern drift av hashable
Hashtbar datastruktur er en rekke bøtter som lagrer nøkkel/verdi-parene i dem. Det gjør bruk av hashCode()-metoden for å bestemme hvilken bøtte nøkkel/verdi-paret skal kartlegge.
Hash-funksjonen hjelper til med å bestemme plasseringen for en gitt nøkkel i bøttelisten. Generelt er hashkode et ikke-negativt heltall som er likt for like objekter og kan være likt for ulikt objekter eller ikke. For å finne ut om to objekter er like eller ikke, bruker hashable metoden equals() .
Det er mulig at to ulike objekter har samme hashkode. Dette kalles en kollisjon . For å løse kollisjoner bruker hashable en rekke lister. Parene som er tilordnet en enkelt bøtte (matriseindeks) lagres i en liste og listereferanse lagres i matriseindeksen.
Metoder for hashable
- K – Typen av nøklene i kartet.
- I – Type verdier kartlagt i kartet.
| METODE | BESKRIVELSE |
|---|---|
| klar() | Tømmer denne hashtabellen slik at den ikke inneholder nøkler. |
| klone() | Oppretter en grunn kopi av denne hashtabellen. |
| compute(K-tast, BiFunction K,? super V,? utvider V> remappingFunction) | Forsøker å beregne en tilordning for den angitte nøkkelen og dens gjeldende tilordnede verdi (eller null hvis det ikke er noen gjeldende tilordning). |
| computeIfAbsent(K-tast, funksjon utvider V> mappingFunction) | Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi (eller er tilordnet til null), forsøker du å beregne verdien ved hjelp av den gitte tilordningsfunksjonen og legger den inn i dette kartet med mindre null. |
| computeIfPresent(K-nøkkel, BiFunction remappingFunction) | Hvis verdien for den angitte nøkkelen er tilstede og ikke er null, forsøker du å beregne en ny tilordning gitt nøkkelen og dens gjeldende tilordnede verdi. |
| inneholder (objektverdi) | Tester om noen nøkkel tilordnes den angitte verdien i denne hashtabellen. |
| containsKey(Objektnøkkel) | Tester om det angitte objektet er en nøkkel i denne hashtabellen. |
| containsValue(Objektverdi) | Returnerer sann hvis denne hashtabellen tilordner én eller flere nøkler til denne verdien. |
| elementer() | Returnerer en oppregning av verdiene i denne hashtabellen. |
| entrySet() | Returnerer en settvisning av tilordningene i dette kartet. |
| lik(Objekt o) | Sammenligner det angitte objektet med dette kartet for likhet, i henhold til definisjonen i kartgrensesnittet. |
| get (objektnøkkel) | Returnerer verdien som den angitte nøkkelen er tilordnet til, eller null hvis denne tilordningen ikke inneholder noen tilordning for nøkkelen. |
| hashkode() | Returnerer hash-kodeverdien for dette kartet i henhold til definisjonen i kartgrensesnittet. |
| er tom() | Tester om denne hashtabellen ikke tilordner noen nøkler til verdier. |
| nøkler() | Returnerer en oppregning av nøklene i denne hashtabellen. |
| keySet() | Returnerer en settvisning av nøklene i dette kartet. |
| flette (K-nøkkel, V-verdi, BiFunction remappingFunction) | Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi eller er assosiert med null, knytter den til den gitte ikke-nullverdien. |
| put(K-tast, V-verdi) | Tilordner den angitte nøkkelen til den angitte verdien i denne hashtabellen. |
| putAll(Kart t) | Kopierer alle tilordningene fra det angitte kartet til denne hashtabellen. |
| rehash() | Øker kapasiteten til og omorganiserer denne hashtabellen internt, for å imøtekomme og få tilgang til oppføringene mer effektivt. |
| fjern (Objektnøkkel) | Fjerner nøkkelen (og dens tilsvarende verdi) fra denne hashtabellen. |
| størrelse() | Returnerer antall nøkler i denne hashtabellen. |
| toString() | Returnerer en strengrepresentasjon av dette Hashtable-objektet i form av et sett med oppføringer, omsluttet av klammeparenteser og atskilt med ASCII-tegn , (komma og mellomrom). |
| verdier() | Returnerer en samlingsvisning av verdiene i dette kartet. |
Metoder deklarert i grensesnittet java.util.Map
| METODE | BESKRIVELSE |
|---|---|
| forEach(BiConsumer action) | Utfører den gitte handlingen for hver oppføring i dette kartet til alle oppføringer er behandlet eller handlingen gir et unntak. |
| getOrDefault(Objektnøkkel, V defaultValue) | Returnerer verdien som den angitte nøkkelen er tilordnet til, eller standardverdi hvis dette kartet ikke inneholder noen tilordning for nøkkelen. |
| putIfAbsent(K-nøkkel, V-verdi) | Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi (eller er tilordnet til null), knytter den til den gitte verdien og returnerer null, ellers returnerer den gjeldende verdien. |
| fjern(Objektnøkkel, Objektverdi) | Fjerner oppføringen for den angitte nøkkelen bare hvis den for øyeblikket er tilordnet den angitte verdien. |
| erstatte (K-tast, V-verdi) | Erstatter oppføringen for den angitte nøkkelen bare hvis den er tilordnet til en verdi. |
| erstatt (K-tast, V oldValue, V newValue) | Erstatter oppføringen for den angitte nøkkelen bare hvis den er tilordnet den angitte verdien. |
| replaceAll(BiFunction-funksjon) | Erstatter hver oppførings verdi med resultatet av å påkalle den gitte funksjonen på den oppføringen til alle oppføringer er behandlet eller funksjonen gir et unntak. |
Må lese:
- Forskjeller mellom HashMap og HashTable i Java
Fordeler med hashable:
- Trådsikker: Hashtable-klassen er trådsikker, noe som betyr at flere tråder kan få tilgang til den samtidig uten å forårsake datakorrupsjon eller andre synkroniseringsproblemer.
- Enkel å bruke: Hashtable-klassen er enkel å bruke og gir grunnleggende nøkkelverdi-datastrukturfunksjonalitet, som kan være nyttig for enkle tilfeller.
Ulemper med hashable:
- Foreldet: Hashtable-klassen anses som foreldet, og bruken frarådes generelt. Dette er fordi det ble designet før introduksjonen av rammeverket for samlinger og ikke implementerer kartgrensesnittet, noe som gjør det vanskelig å bruke det sammen med andre deler av rammeverket.
- Begrenset funksjonalitet: Hashtable-klassen gir grunnleggende nøkkelverdi-datastrukturfunksjonalitet, men gir ikke hele spekteret av funksjonalitet som er tilgjengelig i kartgrensesnittet og dets implementeringer.
- Dårlig ytelse: Hashtable-klassen er synkronisert, noe som kan resultere i tregere ytelse sammenlignet med andre implementeringer av kartgrensesnittet, for eksempel HashMap eller ConcurrentHashMap.
Referanse bøker:
- Java-samlinger av Maurice Naftalin og Philip Wadler. Denne boken gir en omfattende oversikt over Java Collections-rammeverket, inkludert Hashtable-klassen.
- Java i et nøtteskall av David Flanagan. Denne boken gir en rask referanse for kjernefunksjonene til Java, inkludert Hashtable-klassen.
- Java Generics and Collections av Maurice Naftalin og Philip Wadler. Denne boken gir en omfattende guide til generikk og samlinger i Java, inkludert Hashtable-klassen.
Henvisning: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html