De Hastbar klass implementerar en hashtabell, som mappar nycklar till värden. Alla icke-nullobjekt kan användas som en nyckel eller som ett värde. För att framgångsrikt lagra och hämta objekt från en hashtabell måste objekten som används som nycklar implementera hashCode-metoden och equals-metoden.
Klassen java.util.Hashtable är en klass i Java som tillhandahåller en nyckel-värde datastruktur, liknande Map-gränssnittet. Det var en del av det ursprungliga Java Collections-ramverket och introducerades i Java 1.0.
Hashtable-klassen har dock sedan dess ansetts vara föråldrad och dess användning är generellt avrådig. Detta beror på att det designades innan introduktionen av ramverket Samlingar och inte implementerar kartgränssnittet, vilket gör det svårt att använda i kombination med andra delar av ramverket. Dessutom är Hashtable-klassen synkroniserad, vilket kan resultera i långsammare prestanda jämfört med andra implementeringar av Map-gränssnittet.
I allmänhet rekommenderas det att använda kartgränssnittet eller en av dess implementeringar (som HashMap eller ConcurrentHashMap) istället för Hashtable-klassen.
Här är ett exempel på hur du använder klassen 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));> >}> >}> }> |
>
>Produktion
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Sammanfattningsvis, medan Hashtable-klassen fortfarande finns i Java och fortfarande kan användas, rekommenderas det i allmänhet att använda kartgränssnittet eller en av dess implementeringar istället.
Funktioner i Hashtable
- Det liknar HashMap, men är synkroniserat.
- Hashtable lagrar nyckel/värdepar i hashtabell.
- I Hashtable anger vi ett objekt som används som nyckel, och värdet vi vill associera till den nyckeln. Nyckeln hashas sedan och den resulterande hashkoden används som index vid vilket värdet lagras i tabellen.
- Den initiala standardkapaciteten för Hashtable-klassen är 11 medan loadFactor är 0,75.
- HashMap tillhandahåller ingen uppräkning, medan Hashtable inte ger snabb uppräkning.
Deklaration:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Typparametrar:
- K – vilken typ av nycklar som upprätthålls av denna karta
- I – typen av kartlagda värden
Hashtables hierarki
Hastbara redskap Serialiserbar , Klonbar , Karta gränssnitt och utökar Lexikon . De direkta underklasserna är egenskaper, UIDfaults .
Konstruktörer:
För att skapa en hashtabell måste vi importera den från java.util.Hashtable . Det finns olika sätt på vilka vi kan skapa en hashtabell.
1. Hasttabell(): Detta skapar en tom hashtabell med standardbelastningsfaktorn 0,75 och en initial kapacitet är 11.
Hashtable ht = new Hashtable();
Java
allmänt skyddsfel
// 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
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Hashtable(int initialCapacity): Detta skapar en hashtabell som har en initial storlek specificerad av initialCapacity och standardbelastningsfaktorn är 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. Hastbar (int storlek, flytfyllningsförhållande): Den här versionen skapar en hashtabell som har en initial storlek specificerad av storlek och fyllningsförhållande specificerad av fillRatio. Fyllningsförhållande: I grund och botten avgör den hur full en hashtabell kan vara innan den ändras uppåt och dess värde ligger mellan 0,0 och 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. Hasttabell (karta m): Detta skapar en hashtabell som initieras med elementen i m.
Hashtable ht = new Hashtable(Map 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);> >}> }> |
>
>Produktion
Mappings of ht2 : {3=three, 2=two, 1=one}> Exempel:
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> Utföra olika operationer på Hashtable
1. Lägga till element: För att lägga till ett element till hashtabellen kan vi använda put()-metoden. Insättningsordningen behålls dock inte i hashtabellen. Internt, för varje element, genereras en separat hash och elementen indexeras baserat på denna hash för att göra 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);> >}> }> |
>
>Produktion
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Ändra element: Efter att ha lagt till elementen om vi vill ändra elementet, kan det göras genom att återigen lägga till elementet med put()-metoden. Eftersom elementen i hashtabellen indexeras med hjälp av nycklarna, kan värdet på nyckeln ändras genom att helt enkelt infoga det uppdaterade värdet för nyckeln som vi vill ändra.
anslutningar i java
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. Ta bort element: För att ta bort ett element från kartan kan vi använda metoden remove(). Denna metod tar nyckelvärdet och tar bort mappningen för en nyckel från denna karta om den finns i kartan.
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. Traversering av en hashtabell: För att iterera tabellen kan vi använda oss av en avancerat för loop . Nedan är exemplet på att iterera 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());> >}> }> |
>
>Produktion
vaibhav 20 vishal 10 sachin 30>
Internt arbete av Hashtable
Hashtbar datastruktur är en array av hinkar som lagrar nyckel/värdeparen i dem. Den använder sig av hashCode() metod för att bestämma vilken hink nyckel/värdeparet ska mappa.
Hashfunktionen hjälper till att bestämma platsen för en given nyckel i hinklistan. I allmänhet är hashkod ett icke-negativt heltal som är lika för lika objekt och kan vara lika för ojämna objekt eller inte. För att avgöra om två objekt är lika eller inte, använder hashable metoden equals() .
Det är möjligt att två olika objekt har samma hashkod. Detta kallas a kollision . För att lösa kollisioner använder hashable en rad listor. Paren som mappas till en enda hink (matrisindex) lagras i en lista och listreferens lagras i matrisindexet.
Metoder för hashable
- K – Typen av nycklar i kartan.
- I – Typen av värden som mappas i kartan.
| METOD | BESKRIVNING |
|---|---|
| klar() | Rensar denna hashtabell så att den inte innehåller några nycklar. |
| klona() | Skapar en ytlig kopia av denna hashtabell. |
| compute(K-nyckel, BiFunction K,? super V,? utökar V> remappingFunction) | Försöker beräkna en mappning för den angivna nyckeln och dess aktuella mappade värde (eller null om det inte finns någon aktuell mappning). |
| computeIfAbsent(K-tangent, Funktion utökar V> mappingFunction) | Om den angivna nyckeln inte redan är associerad med ett värde (eller är mappad till null), försöker beräkna dess värde med hjälp av den givna mappningsfunktionen och matar in den i denna karta om inte null. |
| computeIfPresent(K-nyckel, BiFunction remappingFunction) | Om värdet för den angivna nyckeln finns och inte är null, försöker man beräkna en ny mappning givet nyckeln och dess aktuella mappade värde. |
| innehåller(Objektvärde) | Testar om några nyckel mappar till det angivna värdet i denna hashtabell. |
| containsKey(Objektnyckel) | Testar om det angivna objektet är en nyckel i denna hashtabell. |
| innehållerValue(Objektvärde) | Returnerar sant om denna hashtabell mappar en eller flera nycklar till detta värde. |
| elements() | Returnerar en uppräkning av värdena i denna hashtabell. |
| entrySet() | Returnerar en Set-vy av mappningarna som finns i denna karta. |
| lika(Objekt o) | Jämför det angivna objektet med denna karta för jämlikhet, enligt definitionen i kartgränssnittet. |
| get (objektnyckel) | Returnerar värdet som den angivna nyckeln är mappad till, eller null om denna karta inte innehåller någon mappning för nyckeln. |
| hash-kod() | Returnerar hashkodvärdet för denna karta enligt definitionen i kartgränssnittet. |
| är tom() | Testar om denna hashtabell inte mappar några nycklar till värden. |
| nycklar() | Returnerar en uppräkning av nycklarna i denna hashtabell. |
| keySet() | Returnerar en Set-vy av nycklarna i denna karta. |
| sammanfoga (K-nyckel, V-värde, BiFunction remappingFunction) | Om den angivna nyckeln inte redan är associerad med ett värde eller är associerad med null, associerar den med det givna icke-nullvärdet. |
| put(K-nyckel, V-värde) | Mappar den angivna nyckeln till det angivna värdet i denna hashtabell. |
| putAll(Map t) | Kopierar alla mappningar från den angivna kartan till denna hashtabell. |
| uppkok() | Ökar kapaciteten och omorganiserar internt denna hashtabell för att kunna ta emot och komma åt dess poster mer effektivt. |
| ta bort (objektnyckel) | Tar bort nyckeln (och dess motsvarande värde) från denna hashtabell. |
| storlek() | Returnerar antalet nycklar i denna hashtabell. |
| att stränga() | Returnerar en strängrepresentation av detta Hashtable-objekt i form av en uppsättning poster, omslutna av klammerparenteser och åtskilda av ASCII-tecken , (komma och mellanslag). |
| värden() | Returnerar en samlingsvy av värdena som finns i denna karta. |
Metoder som deklareras i gränssnittet java.util.Map
| METOD | BESKRIVNING |
|---|---|
| forEach(BiConsumer action) | Utför den givna åtgärden för varje post i denna karta tills alla poster har bearbetats eller åtgärden ger ett undantag. |
| getOrDefault(Objektnyckel, V defaultValue) | Returnerar värdet som den angivna nyckeln är mappad till, eller defaultValue om denna karta inte innehåller någon mappning för nyckeln. |
| putIfAbsent(K-nyckel, V-värde) | Om den angivna nyckeln inte redan är associerad med ett värde (eller är mappad till null) associerar den med det givna värdet och returnerar null, annars returnerar det aktuella värdet. |
| ta bort (Objektnyckel, Objektvärde) | Tar endast bort posten för den angivna nyckeln om den för närvarande är mappad till det angivna värdet. |
| ersätt (K-nyckel, V-värde) | Ersätter posten för den angivna nyckeln endast om den för närvarande är mappad till något värde. |
| ersätt (K-nyckel, V oldValue, V newValue) | Ersätter posten för den angivna nyckeln endast om den är mappad till det angivna värdet. |
| replaceAll(BiFunction-funktion) | Ersätter varje posts värde med resultatet av att anropa den givna funktionen på den posten tills alla poster har bearbetats eller funktionen ger ett undantag. |
Måste läsas:
- Skillnader mellan HashMap och HashTable i Java
Fördelar med Hashtable:
- Trådsäker: Hashtable-klassen är trådsäker, vilket innebär att flera trådar kan komma åt den samtidigt utan att orsaka datakorruption eller andra synkroniseringsproblem.
- Enkel att använda: Hashtable-klassen är enkel att använda och tillhandahåller grundläggande nyckel-värde datastrukturfunktioner, vilket kan vara användbart för enkla fall.
Nackdelar med Hashtable:
- Föråldrad: Hashtable-klassen anses vara föråldrad och dess användning avråds i allmänhet. Detta beror på att det designades innan introduktionen av ramverket Samlingar och inte implementerar kartgränssnittet, vilket gör det svårt att använda i kombination med andra delar av ramverket.
- Begränsad funktionalitet: Hashtable-klassen tillhandahåller grundläggande nyckel-värde datastrukturfunktionalitet, men tillhandahåller inte hela utbudet av funktionalitet som är tillgängligt i kartgränssnittet och dess implementeringar.
- Dålig prestanda: Hashtable-klassen är synkroniserad, vilket kan resultera i långsammare prestanda jämfört med andra implementeringar av kartgränssnittet, såsom HashMap eller ConcurrentHashMap.
Uppslagsverk:
- Java-samlingar av Maurice Naftalin och Philip Wadler. Den här boken ger en omfattande översikt över Java Collections-ramverket, inklusive Hashtable-klassen.
- Java i ett nötskal av David Flanagan. Den här boken ger en snabbreferens för kärnfunktionerna i Java, inklusive Hashtable-klassen.
- Java Generics and Collections av Maurice Naftalin och Philip Wadler. Den här boken ger en omfattande guide till generika och samlingar i Java, inklusive Hashtable-klassen.
Referens: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html