Der Hash-tabelle Die Klasse implementiert eine Hash-Tabelle, die Schlüssel Werten zuordnet. Jedes Nicht-Null-Objekt kann als Schlüssel oder als Wert verwendet werden. Um Objekte erfolgreich in einer Hashtabelle zu speichern und abzurufen, müssen die als Schlüssel verwendeten Objekte die Methode hashCode und die Methode equal implementieren.
Die Klasse java.util.Hashtable ist eine Klasse in Java, die eine Schlüsselwert-Datenstruktur bereitstellt, ähnlich der Map-Schnittstelle. Es war Teil des ursprünglichen Java Collections-Frameworks und wurde in Java 1.0 eingeführt.
Allerdings gilt die Hashtable-Klasse inzwischen als veraltet und von ihrer Verwendung wird generell abgeraten. Dies liegt daran, dass es vor der Einführung des Collections-Frameworks entwickelt wurde und die Map-Schnittstelle nicht implementiert, was die Verwendung in Verbindung mit anderen Teilen des Frameworks erschwert. Darüber hinaus ist die Hashtable-Klasse synchronisiert, was im Vergleich zu anderen Implementierungen der Map-Schnittstelle zu einer langsameren Leistung führen kann.
Im Allgemeinen wird empfohlen, anstelle der Hashtable-Klasse die Map-Schnittstelle oder eine ihrer Implementierungen (z. B. HashMap oder ConcurrentHashMap) zu verwenden.
Hier ist ein Beispiel für die Verwendung der Hashtable-Klasse:
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));> >}> >}> }> |
>
>Ausgabe
Finde mein iPhone Android
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Zusammenfassend lässt sich sagen, dass die Hashtable-Klasse zwar immer noch in Java vorhanden ist und weiterhin verwendet werden kann, es wird jedoch allgemein empfohlen, stattdessen die Map-Schnittstelle oder eine ihrer Implementierungen zu verwenden.
Funktionen von Hashtable
- Es ähnelt HashMap, ist jedoch synchronisiert.
- Hashtable speichert Schlüssel/Wert-Paare in der Hash-Tabelle.
- In Hashtable geben wir ein Objekt an, das als Schlüssel verwendet wird, und den Wert, den wir diesem Schlüssel zuordnen möchten. Der Schlüssel wird dann gehasht und der resultierende Hash-Code wird als Index verwendet, an dem der Wert in der Tabelle gespeichert wird.
- Die anfängliche Standardkapazität der Hashtable-Klasse beträgt 11, während LoadFactor 0,75 beträgt.
- HashMap bietet keine Aufzählung, während Hashtable keine ausfallsichere Aufzählung bereitstellt.
Erklärung:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Typparameter:
- K – die Art der von dieser Karte verwalteten Schlüssel
- IN – die Art der zugeordneten Werte
Die Hierarchie von Hashtable
Hashtable implementiert Serialisierbar , Klonbar , Karte Schnittstellen und Erweiterungen Wörterbuch . Die direkten Unterklassen sind Properties , UIDefaults .
Konstrukteure:
Um eine Hashtabelle zu erstellen, müssen wir sie importieren java.util.Hashtable . Es gibt verschiedene Möglichkeiten, eine Hashtabelle zu erstellen.
1. Hashtable(): Dadurch wird eine leere Hashtabelle mit dem Standardladefaktor 0,75 und einer Anfangskapazität von 11 erstellt.
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);> >}> }> |
>
>Ausgabe
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Hashtable(int initialCapacity): Dadurch wird eine Hash-Tabelle erstellt, deren Anfangsgröße durch initialCapacity angegeben wird und deren Standardladefaktor 0,75 beträgt.
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);> >}> }> |
>
>Ausgabe
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Hashtable(int size, float fillRatio): Diese Version erstellt eine Hash-Tabelle mit einer Anfangsgröße, die durch „size“ und einem durch „fillRatio“ angegebenen Füllverhältnis angegeben wird. Füllverhältnis: Im Grunde bestimmt es, wie voll eine Hash-Tabelle sein kann, bevor ihre Größe nach oben geändert wird, und ihr Wert liegt zwischen 0,0 und 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);> >}> }> |
Dateisystem unter Linux
>
>Ausgabe
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Hashtable(Map m): Dadurch wird eine Hash-Tabelle erstellt, die mit den Elementen in m initialisiert wird.
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);> >}> }> |
>
>Ausgabe
Mappings of ht2 : {3=three, 2=two, 1=one}> Beispiel:
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);> >}> >}> }> |
vergleichbare Saite
>
>Ausgabe
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Durchführen verschiedener Vorgänge an Hashtable
1. Elemente hinzufügen: Um der Hashtabelle ein Element hinzuzufügen, können wir die Methode put() verwenden. Die Einfügungsreihenfolge bleibt jedoch nicht in der Hashtabelle erhalten. Intern wird für jedes Element ein separater Hash generiert und die Elemente werden basierend auf diesem Hash indiziert, um die Effizienz zu erhöhen.
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);> >}> }> |
>
>Ausgabe
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Elemente ändern: Wenn wir nach dem Hinzufügen der Elemente das Element ändern möchten, können wir dies tun, indem wir das Element erneut mit der Methode put() hinzufügen. Da die Elemente in der Hashtabelle mithilfe der Schlüssel indiziert werden, kann der Wert des Schlüssels geändert werden, indem einfach der aktualisierte Wert für den Schlüssel eingegeben wird, den wir ändern möchten.
Java
YouTube-Video vlc speichern
// 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);> >}> }> |
>
>Ausgabe
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Element entfernen: Um ein Element aus der Map zu entfernen, können wir die Methode „remove()“ verwenden. Diese Methode nimmt den Schlüsselwert und entfernt die Zuordnung für einen Schlüssel aus dieser Zuordnung, sofern er in der Zuordnung vorhanden ist.
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);> >}> }> |
>
>Ausgabe
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Durchquerung einer Hashtabelle: Um die Tabelle zu iterieren, können wir eine verwenden erweiterte for-Schleife . Unten finden Sie ein Beispiel für die Iteration einer Hashtabelle.
Java
binäre Baumtypen
// 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());> >}> }> |
>
>Ausgabe
vaibhav 20 vishal 10 sachin 30>
Interne Funktionsweise von Hashtable
Die Hashtable-Datenstruktur ist ein Array von Buckets, in denen die Schlüssel/Wert-Paare gespeichert werden. Es nutzt aus hashCode() method um zu bestimmen, welchen Bucket das Schlüssel/Wert-Paar zuordnen soll.
Die Hash-Funktion hilft dabei, die Position für einen bestimmten Schlüssel in der Bucket-Liste zu bestimmen. Im Allgemeinen ist ein Hashcode eine nicht negative Ganzzahl, die für gleiche Objekte gleich ist und für ungleiche Objekte gleich sein kann oder auch nicht. Um festzustellen, ob zwei Objekte gleich sind oder nicht, verwendet Hashtable die Methode equal().
Es ist möglich, dass zwei ungleiche Objekte denselben Hashcode haben. Dies nennt man a Kollision . Um Kollisionen aufzulösen, verwendet Hashtable ein Array von Listen. Die einem einzelnen Bucket (Array-Index) zugeordneten Paare werden in einer Liste gespeichert und die Listenreferenz wird im Array-Index gespeichert.
Methoden von Hashtable
- K – Der Typ der Schlüssel in der Karte.
- IN – Die Art der in der Karte abgebildeten Werte.
| METHODE | BESCHREIBUNG |
|---|---|
| klar() | Löscht diese Hashtabelle, sodass sie keine Schlüssel enthält. |
| Klon() | Erstellt eine flache Kopie dieser Hashtabelle. |
| berechnen(K-Taste, BiFunction K,? super V,? erweitert V> remappingFunction) | Versucht, eine Zuordnung für den angegebenen Schlüssel und seinen aktuell zugeordneten Wert zu berechnen (oder null, wenn keine aktuelle Zuordnung vorhanden ist). |
| computeIfAbsent(K-Taste, Funktion erweitert V> MappingFunction) | Wenn der angegebene Schlüssel noch nicht mit einem Wert verknüpft ist (oder auf Null abgebildet ist), versucht er, seinen Wert mithilfe der angegebenen Zuordnungsfunktion zu berechnen, und gibt ihn in diese Zuordnung ein, sofern er nicht Null ist. |
| computeIfPresent(K-Taste, BiFunction remappingFunction) | Wenn der Wert für den angegebenen Schlüssel vorhanden und ungleich Null ist, wird versucht, eine neue Zuordnung anhand des Schlüssels und seines aktuellen zugeordneten Werts zu berechnen. |
| enthält(Objektwert) | Testet, ob einige Schlüssel dem angegebenen Wert in dieser Hashtabelle zugeordnet sind. |
| enthältKey(Objektschlüssel) | Testet, ob das angegebene Objekt ein Schlüssel in dieser Hashtabelle ist. |
| enthältWert(Objektwert) | Gibt „true“ zurück, wenn diese Hashtabelle diesem Wert einen oder mehrere Schlüssel zuordnet. |
| Elemente() | Gibt eine Aufzählung der Werte in dieser Hashtabelle zurück. |
| EintragSet() | Gibt eine Set-Ansicht der in dieser Karte enthaltenen Zuordnungen zurück. |
| equal(Objekt o) | Vergleicht das angegebene Objekt mit dieser Map auf Gleichheit gemäß der Definition in der Map-Schnittstelle. |
| get(Objektschlüssel) | Gibt den Wert zurück, dem der angegebene Schlüssel zugeordnet ist, oder null, wenn diese Zuordnung keine Zuordnung für den Schlüssel enthält. |
| Hash-Code() | Gibt den Hash-Codewert für diese Map gemäß der Definition in der Map-Schnittstelle zurück. |
| ist leer() | Testet, ob diese Hashtabelle keine Schlüssel zu Werten zuordnet. |
| Schlüssel() | Gibt eine Aufzählung der Schlüssel in dieser Hashtabelle zurück. |
| Schlüsselsatz() | Gibt eine Set-Ansicht der in dieser Karte enthaltenen Schlüssel zurück. |
| merge(K-Taste, V-Wert, BiFunction remappingFunction) | Wenn der angegebene Schlüssel noch keinem Wert zugeordnet ist oder mit Null verknüpft ist, ordnet er ihn dem angegebenen Nicht-Null-Wert zu. |
| put(K-Taste, V-Wert) | Ordnet den angegebenen Schlüssel dem angegebenen Wert in dieser Hashtabelle zu. |
| putAll(Map t) | Kopiert alle Zuordnungen von der angegebenen Karte in diese Hashtabelle. |
| aufwärmen() | Erhöht die Kapazität dieser Hashtabelle und organisiert sie intern neu, um ihre Einträge effizienter unterzubringen und darauf zuzugreifen. |
| entfernen(Objektschlüssel) | Entfernt den Schlüssel (und seinen entsprechenden Wert) aus dieser Hashtabelle. |
| Größe() | Gibt die Anzahl der Schlüssel in dieser Hashtabelle zurück. |
| toString() | Gibt eine Zeichenfolgendarstellung dieses Hashtable-Objekts in Form einer Reihe von Einträgen zurück, die in geschweifte Klammern eingeschlossen und durch die ASCII-Zeichen (Komma und Leerzeichen) getrennt sind. |
| Werte() | Gibt eine Sammlungsansicht der in dieser Karte enthaltenen Werte zurück. |
In der Schnittstelle java.util.Map deklarierte Methoden
| METHODE | BESCHREIBUNG |
|---|---|
| forEach(BiConsumer-Aktion) | Führt die angegebene Aktion für jeden Eintrag in dieser Karte aus, bis alle Einträge verarbeitet wurden oder die Aktion eine Ausnahme auslöst. |
| getOrDefault(Objektschlüssel, V defaultValue) | Gibt den Wert zurück, dem der angegebene Schlüssel zugeordnet ist, oder defaultValue, wenn diese Zuordnung keine Zuordnung für den Schlüssel enthält. |
| putIfAbsent(K-Taste, V-Wert) | Wenn der angegebene Schlüssel noch keinem Wert zugeordnet ist (oder auf null abgebildet ist), wird er mit dem angegebenen Wert verknüpft und null zurückgegeben, andernfalls wird der aktuelle Wert zurückgegeben. |
| entfernen(Objektschlüssel, Objektwert) | Entfernt den Eintrag für den angegebenen Schlüssel nur, wenn er derzeit dem angegebenen Wert zugeordnet ist. |
| ersetzen(K-Taste, V-Wert) | Ersetzt den Eintrag für den angegebenen Schlüssel nur, wenn er derzeit einem Wert zugeordnet ist. |
| ersetzen(K-Taste, V alter Wert, V neuer Wert) | Ersetzt den Eintrag für den angegebenen Schlüssel nur, wenn er aktuell dem angegebenen Wert zugeordnet ist. |
| replaceAll(BiFunction-Funktion) | Ersetzt den Wert jedes Eintrags durch das Ergebnis des Aufrufs der angegebenen Funktion für diesen Eintrag, bis alle Einträge verarbeitet wurden oder die Funktion eine Ausnahme auslöst. |
Muss lesen:
- Unterschiede zwischen HashMap und HashTable in Java
Vorteile von Hashtable:
- Thread-sicher: Die Hashtable-Klasse ist Thread-sicher, was bedeutet, dass mehrere Threads gleichzeitig darauf zugreifen können, ohne dass es zu Datenbeschädigungen oder anderen Synchronisierungsproblemen kommt.
- Einfach zu verwenden: Die Hashtable-Klasse ist einfach zu verwenden und bietet grundlegende Schlüsselwert-Datenstrukturfunktionen, die in einfachen Fällen nützlich sein können.
Nachteile von Hashtable:
- Veraltet: Die Hashtable-Klasse gilt als veraltet und von ihrer Verwendung wird generell abgeraten. Dies liegt daran, dass es vor der Einführung des Collections-Frameworks entwickelt wurde und die Map-Schnittstelle nicht implementiert, was die Verwendung in Verbindung mit anderen Teilen des Frameworks erschwert.
- Eingeschränkte Funktionalität: Die Hashtable-Klasse bietet grundlegende Schlüsselwert-Datenstrukturfunktionen, bietet jedoch nicht den gesamten Funktionsumfang, der in der Map-Schnittstelle und ihren Implementierungen verfügbar ist.
- Schlechte Leistung: Die Hashtable-Klasse ist synchronisiert, was im Vergleich zu anderen Implementierungen der Map-Schnittstelle wie HashMap oder ConcurrentHashMap zu einer langsameren Leistung führen kann.
Nachschlagewerke:
- Java-Sammlungen von Maurice Naftalin und Philip Wadler. Dieses Buch bietet einen umfassenden Überblick über das Java Collections-Framework, einschließlich der Hashtable-Klasse.
- Java auf den Punkt gebracht von David Flanagan. Dieses Buch bietet eine Kurzreferenz für die Kernfunktionen von Java, einschließlich der Hashtable-Klasse.
- Java Generics and Collections von Maurice Naftalin und Philip Wadler. Dieses Buch bietet eine umfassende Anleitung zu Generika und Sammlungen in Java, einschließlich der Hashtable-Klasse.
Referenz: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html