The Hashtable clasa implementează un tabel hash, care mapează cheile la valori. Orice obiect non-null poate fi folosit ca cheie sau ca valoare. Pentru a stoca și a prelua cu succes obiecte dintr-un tabel hash, obiectele utilizate ca chei trebuie să implementeze metoda hashCode și metoda equals.
Clasa java.util.Hashtable este o clasă în Java care oferă o structură de date cheie-valoare, similară cu interfața Map. A făcut parte din cadrul original Java Collections și a fost introdus în Java 1.0.
Cu toate acestea, clasa Hashtable a fost considerată învechită și utilizarea ei este în general descurajată. Acest lucru se datorează faptului că a fost proiectat înainte de introducerea cadrului Collections și nu implementează interfața Map, ceea ce face dificilă utilizarea împreună cu alte părți ale cadrului. În plus, clasa Hashtable este sincronizată, ceea ce poate duce la o performanță mai lentă în comparație cu alte implementări ale interfeței Map.
În general, este recomandat să utilizați interfața Map sau una dintre implementările acesteia (cum ar fi HashMap sau ConcurrentHashMap) în loc de clasa Hashtable.
Iată un exemplu de utilizare a clasei 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));> >}> >}> }> |
>
>Ieșire
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
În concluzie, deși clasa Hashtable încă există în Java și poate fi folosită, în general este recomandat să folosiți interfața Map sau una dintre implementările acesteia.
Caracteristicile Hashtable
- Este similar cu HashMap, dar este sincronizat.
- Hashtable stochează perechea cheie/valoare în tabelul hash.
- În Hashtable specificăm un obiect care este folosit ca cheie și valoarea pe care dorim să o asociem acelei chei. Cheia este apoi hash, iar codul hash rezultat este folosit ca index la care valoarea este stocată în tabel.
- Capacitatea implicită inițială a clasei Hashtable este 11, în timp ce loadFactor este 0,75.
- HashMap nu oferă nicio enumerare, în timp ce Hashtable nu oferă o enumerare rapidă.
Declaraţie:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Parametri de tip:
făcând executabil un script shell
- K – tipul de chei întreținute de această hartă
- ÎN – tipul valorilor mapate
Ierarhia Hashtable
Instrumente hashtable Serializabil , Clonabil , Hartă interfețe și se extinde Dicţionar . Subclasele directe sunt Proprietăți, UIDdefaults .
Constructori:
Pentru a crea un Hashtable, trebuie să îl importăm din java.util.Hashtable . Există diferite moduri prin care putem crea un Hashtable.
1. Hashtable(): Acest lucru creează un hashtable gol cu factorul de încărcare implicit de 0,75 și o capacitate inițială este 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);> >}> }> |
>
>Ieșire
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Hashtable(int initialCapacity): Aceasta creează un tabel hash care are o dimensiune inițială specificată de initialCapacity și factorul de încărcare implicit este 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);> >}> }> |
>
>Ieșire
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Hashtable (int size, float fillRatio): Această versiune creează un tabel hash care are o dimensiune inițială specificată de dimensiune și raport de umplere specificat de fillRatio. raportul de umplere: practic, determină cât de plin poate fi un tabel hash înainte de a fi redimensionat în sus, iar valoarea sa este cuprinsă între 0,0 și 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);> >}> }> |
>
>Ieșire
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Hashtable (Harta m): Aceasta creează un tabel hash care este inițializat cu elementele din m.
Hashtable ht = new Hashtable(Harta 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);> >}> }> |
>
>Ieșire
Mappings of ht2 : {3=three, 2=two, 1=one}> Exemplu:
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);> >}> >}> }> |
>
>Ieșire
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Efectuarea diferitelor operații pe Hashtable
1. Adăugarea de elemente: Pentru a adăuga un element la tabelul hash, putem folosi metoda put(). Cu toate acestea, ordinea de inserare nu este reținută în tabelul hash. Intern, pentru fiecare element, este generat un hash separat, iar elementele sunt indexate pe baza acestui hash pentru a-l face mai eficient.
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);> >}> }> |
>
>Ieșire
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Schimbarea elementelor: După adăugarea elementelor dacă dorim să schimbăm elementul, se poate face prin adăugarea din nou a elementului cu metoda put(). Deoarece elementele din tabelul hash sunt indexate folosind chei, valoarea cheii poate fi modificată prin simpla inserare a valorii actualizate pentru cheia pentru care dorim să o modificăm.
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);> >}> }> |
>
>Ieșire
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Scoaterea elementului: Pentru a elimina un element din Hartă, putem folosi metoda remove(). Această metodă preia valoarea cheii și elimină maparea pentru o cheie de pe această hartă dacă aceasta este prezentă pe hartă.
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);> >}> }> |
>
>Ieșire
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Traversarea unui Hashtable: Pentru a repeta tabelul, putem folosi un avansate pentru buclă . Mai jos este exemplul de iterare a unui tabel hash.
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());> >}> }> |
>
>Ieșire
vaibhav 20 vishal 10 sachin 30>
Funcționarea internă a Hashtable-ului
Structura de date hashtable este o matrice de compartimente care stochează perechile cheie/valoare în ele. Face uz de metoda hashCode(). pentru a determina ce compartiment ar trebui mapat perechea cheie/valoare.
Funcția hash ajută la determinarea locației pentru o anumită cheie în lista de găleți. În general, hashcode este un număr întreg nenegativ care este egal pentru obiecte egale și poate fi sau nu egal pentru obiecte inegale. Pentru a determina dacă două obiecte sunt egale sau nu, hashtable folosește metoda equals().
Este posibil ca două Obiecte inegale să aibă același cod hash. Aceasta se numește a coliziune . Pentru a rezolva coliziunile, hashtable folosește o serie de liste. Perechile mapate la o singură găleată (index de matrice) sunt stocate într-o listă, iar referința de listă este stocată în indexul de matrice.
Metode de Hashtable
- K – Tipul cheilor din hartă.
- ÎN – Tipul de valori mapate în hartă.
| METODĂ | DESCRIERE |
|---|---|
| clar() | Șterge această tabelă hash, astfel încât să nu conțină chei. |
| clona() | Creează o copie superficială a acestui tabel hash. |
| calculează (tasta K, BiFunction K,? super V,? extinde V> remappingFunction) | Încearcă să calculeze o mapare pentru cheia specificată și valoarea sa mapată curentă (sau nulă dacă nu există o mapare curentă). |
| computeIfAbsent (tasta K, Funcție extinde V> mappingFunction) | Dacă cheia specificată nu este deja asociată cu o valoare (sau este mapată la null), încearcă să-și calculeze valoarea utilizând funcția de mapare dată și o introduce în această hartă, dacă nu este nulă. |
| computeIfPresent (tasta K, funcția de remapare BiFunction) | Dacă valoarea pentru cheia specificată este prezentă și nu este nulă, încearcă să calculeze o nouă mapare având în vedere cheia și valoarea sa mapată curentă. |
| conţine (valoarea obiectului) | Testează dacă unele chei se potrivesc cu valoarea specificată în acest tabel hash. |
| containsKey(cheie obiect) | Testează dacă obiectul specificat este o cheie în acest tabel hash. |
| containsValue(Valoare obiect) | Returnează true dacă această tabelă hash mapează una sau mai multe chei la această valoare. |
| elemente() | Returnează o enumerare a valorilor din acest tabel hash. |
| entrySet() | Returnează o vizualizare Set a mapărilor conținute în această hartă. |
| este egal(obiect o) | Compară obiectul specificat cu această hartă pentru egalitate, conform definiției din interfața Hartă. |
| get(cheie obiect) | Returnează valoarea la care este mapată cheia specificată sau nulă dacă această hartă nu conține nicio mapare pentru cheie. |
| hashCode() | Returnează valoarea codului hash pentru această hartă conform definiției din interfața Hartă. |
| este gol() | Testează dacă această tabelă hash nu mapează nicio cheie la valori. |
| chei() | Returnează o enumerare a cheilor din această tabelă hash. |
| keySet() | Returnează o vizualizare Set a cheilor conținute în această hartă. |
| îmbinare (tasta K, valoarea V, funcția de remapare BiFunction) | Dacă cheia specificată nu este deja asociată cu o valoare sau este asociată cu null, o asociază cu valoarea non-nulă dată. |
| pune (tasta K, valoarea V) | Mapează cheia specificată la valoarea specificată în acest tabel hash. |
| putAll(Harta t) | Copiază toate mapările de pe harta specificată în această tabelă hash. |
| rehash() | Crește capacitatea și reorganizează intern acest hashtable, pentru a acomoda și a accesa intrările sale mai eficient. |
| eliminați (cheia obiectului) | Îndepărtează cheia (și valoarea ei corespunzătoare) din această tabelă hash. |
| mărimea() | Returnează numărul de chei din această tabelă hash. |
| toString() | Returnează o reprezentare șir a acestui obiect Hashtable sub forma unui set de intrări, cuprinse între acolade și separate prin caracterele ASCII , (virgulă și spațiu). |
| valori () | Returnează o vizualizare de colecție a valorilor conținute în această hartă. |
Metode declarate în interfața java.util.Map
| METODĂ | DESCRIERE |
|---|---|
| forEach (acțiune BiConsumer) | Efectuează acțiunea dată pentru fiecare intrare din această hartă până când toate intrările au fost procesate sau acțiunea aruncă o excepție. |
| getOrDefault(cheia obiectului, V defaultValue) | Returnează valoarea la care este mapată cheia specificată sau defaultValue dacă această hartă nu conține nicio mapare pentru cheie. |
| putIfAbsent(tasta K, valoarea V) | Dacă cheia specificată nu este deja asociată cu o valoare (sau este mapată la null) o asociază cu valoarea dată și returnează null, altfel returnează valoarea curentă. |
| eliminați (cheia obiectului, Valoarea obiectului) | Elimină intrarea pentru cheia specificată numai dacă este mapată în prezent la valoarea specificată. |
| înlocuiți (tasta K, valoarea V) | Înlocuiește intrarea pentru cheia specificată numai dacă în prezent este mapată la o anumită valoare. |
| înlocuiți (tasta K, V vecheValoare, V nouăValoare) | Înlocuiește intrarea pentru cheia specificată numai dacă este mapată în prezent la valoarea specificată. |
| replaceAll (funcția BiFunction) | Înlocuiește valoarea fiecărei intrări cu rezultatul invocării funcției date pe acea intrare până când toate intrările au fost procesate sau funcția aruncă o excepție. |
Trebuie citit:
- Diferențele dintre HashMap și HashTable în Java
Avantajele Hashtable:
- Thread-safe: clasa Hashtable este thread-safe, ceea ce înseamnă că mai multe fire de execuție o pot accesa simultan fără a provoca coruperea datelor sau alte probleme de sincronizare.
- Simplu de utilizat: clasa Hashtable este simplu de utilizat și oferă funcționalitate de bază a structurii de date cheie-valoare, care poate fi utilă pentru cazuri simple.
Dezavantajele Hashtable:
- Învechit: clasa Hashtable este considerată învechită și utilizarea acesteia este în general descurajată. Acest lucru se datorează faptului că a fost proiectat înainte de introducerea cadrului Collections și nu implementează interfața Map, ceea ce face dificilă utilizarea împreună cu alte părți ale cadrului.
- Funcționalitate limitată: clasa Hashtable oferă funcționalități de bază ale structurii de date cheie-valoare, dar nu oferă întreaga gamă de funcționalități disponibile în interfața Map și implementările acesteia.
- Performanță slabă: clasa Hashtable este sincronizată, ceea ce poate duce la o performanță mai lentă în comparație cu alte implementări ale interfeței Map, cum ar fi HashMap sau ConcurrentHashMap.
Carti de referinta:
- Colecții Java de Maurice Naftalin și Philip Wadler. Această carte oferă o privire de ansamblu cuprinzătoare asupra cadrului Java Collections, inclusiv a clasei Hashtable.
- Java pe scurt de David Flanagan. Această carte oferă o referință rapidă pentru caracteristicile de bază ale Java, inclusiv clasa Hashtable.
- Generice și colecții Java de Maurice Naftalin și Philip Wadler. Această carte oferă un ghid cuprinzător pentru generice și colecții în Java, inclusiv clasa Hashtable.
Referinţă: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html