Java Hashtable Klasse

Einführung

Hallo dort, zukünftige Java-Zauberer! Heute werden wir auf eine aufregende Reise in die Welt der Java-Hashtabellen einsteigen. Ich weiß, was ihr vielleicht denkt: "Hashtabellen? Das klingt so spannend wie das Zuschauen, wie Farbe trocknet!" Aber glaubt mir, sobald ihr die Macht der Hashtabellen versteht, werdet ihr sehen, wie sie euer Programmierleben so viel einfacher machen können.

Stellt euch vor, ihr versucht, eure umfangreiche Sammlung von Gummiente zu organisieren (weil wer hat nicht eine davon, oder?). Ihr könntet sie einfach in eine große Box werfen, aber dann wäre das Finden eures Lieblings-Piratengummientes ein Alptraum. Hier kommt eine Hashtabelle ins Spiel – es ist, als würde jedes Entchen seinen eigenen beschrifteten Regalplatz bekommen, sodass ihr jedes Entchen sofort finden könnt.

Klassendeklaration

Beginnen wir mit den Grundlagen. In Java wird eine Hashtabelle wie folgt deklariert:

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable

Lasst euch das nicht abschrecken! Es ist nur Java's Weg, zu sagen: "Hey, ich bin eine Hashtabelle, und ich kann mit verschiedenen Arten von Schlüsseln (K) und Werten (V) arbeiten." Stellt euch vor, es ist ein intelligenter Container, der Paare von Dingen wie einen Namen (Schlüssel) und eine Telefonnummer (Wert) halten kann.

Klassenkonstruktoren

Nun schauen wir uns, wie wir eine Hashtabelle erstellen können. Es ist wie das Bauen eures Gummienten-Regals – ihr habt einige Optionen:

// Eine leere Hashtabelle erstellen
Hashtable<String, Integer> gummientensammlung = new Hashtable<>();

// Eine Hashtabelle mit einer initialen Kapazität erstellen
Hashtable<String, Integer> grosseGummientensammlung = new Hashtable<>(100);

// Eine Hashtabelle von einer anderen Map erstellen
Map<String, Integer> bestehendeEnten = new HashMap<>();
Hashtable<String, Integer> kopierteEnten = new Hashtable<>(bestehendeEnten);

In dem ersten Beispiel erstellen wir einen leeren Regalplatz für unsere Enten. In dem zweiten sagen wir: "Ich werde viele Enten haben, lasst uns also einen großen Regalplatz machen!" Und in dem dritten kopieren wir Enten von einer anderen Sammlung.

Klassenmethoden

Hashtabellen kommen mit einer Werkzeugkiste voller nützlicher Methoden. Lassen Sie uns einige davon erkunden:

Hashtable<String, Integer> enteninventar = new Hashtable<>();

// Ein Entchen hinzufügen
enteninventar.put("Gummipiratenten", 5);

// Die Anzahl der Piratenten abrufen
int piratenten = enteninventar.get("Gummipiratenten");

// Überprüfen, ob wir Ninja-Enten haben
boolean hatNinjaEnten = enteninventar.containsKey("Gumminja-Enten");

// Alle Enten entfernen (oh nein!)
enteninventar.clear();

// Überprüfen, ob unser Inventar leer ist
boolean istEntenlosUndTraurig = enteninventar.isEmpty();

Jede dieser Methoden hilft uns, unsere Entensammlung zu verwalten. Wir können Enten hinzufügen, überprüfen, wie viele wir haben, sehen, ob wir eine bestimmte Art haben, unsere Sammlung leeren (aber warum sollten wir?) und überprüfen, ob wir ausser Enten sind (eine Tragödie!).

Vererbte Methoden

Die Hashtabelle ist Teil einer größeren Familie in Java und erbt einige Methoden von ihren Verwandten. Hier ist eine Tabelle einiger wichtiger vererbarter Methoden:

Methode	Vererbt von	Beschreibung
clone()	Object	Erstellt eine flache Kopie der Hashtabelle
equals(Object o)	Object	Vergleicht diese Hashtabelle mit einem anderen Objekt
hashCode()	Object	Liefert einen Hash-Code für diese Hashtabelle
toString()	Object	Liefert eine Zeichenkettendarstellung der Hashtabelle
putAll(Map<? extends K,? extends V> t)	Map	Kopiert alle Zuordnungen von der angegebenen Map in diese Hashtabelle

Diese Methoden sind wie zusätzliche Funktionen, die mit Ihrem Entenregal kommen. Ihr könnt eine Kopie eurer Sammlung machen, sie mit anderen Sammlungen vergleichen, einen eindeutigen Code dafür erhalten, sie in eine Beschreibung umwandeln oder sogar gleichzeitig viele Enten hinzufügen!

Hinzufügen eines Mapping zu einer HashTable von Integer, Integer-Paar Beispiel

Lassen Sie uns all diese Kenntnisse mit einem komplexeren Beispiel in die Praxis umsetzen:

public class Entenzähler {
public static void main(String[] args) {
// Eine Hashtabelle erstellen, um Entenarten und ihre Anzahlen zu speichern
Hashtable<Integer, Integer> entenzensus = new Hashtable<>();

// Einige Entenzahlen hinzufügen
entenzensus.put(1, 10);  // Entenart 1: 10 Enten
entenzensus.put(2, 15);  // Entenart 2: 15 Enten
entenzensus.put(3, 5);   // Entenart 3: 5 Enten

// Unseren Entenzensus ausgeben
System.out.println("Entenzensus: " + entenzensus);

// Lassen Sie uns mehr Enten vom Typ 2 hinzufügen
int aktuelleTyp2Anzahl = entenzensus.get(2);
entenzensus.put(2, aktuelleTyp2Anzahl + 5);

// Überprüfen wir unsere aktualisierte Anzahl
System.out.println("Aktualisierter Entenzensus: " + entenzensus);

// Oh nein! Alle Enten vom Typ 3 sind weggeflogen
entenzensus.remove(3);

// Endgültige Entenanzahl
System.out.println("Endgültiger Entenzensus: " + entenzensus);
}
}

In diesem Beispiel verwenden wir eine Hashtabelle, um verschiedene Arten von Enten zu verfolgen. Jede Entenart wird mit einer Zahl (dem Schlüssel) versehen, und wir speichern die Anzahl der Enten (den Wert). Wir fügen Enten hinzu, aktualisieren ihre Zahlen und behandeln sogar den großen Entenflucht des Typs 3!

Wenn ihr diesen Code ausführt, werdet ihr sehen, wie sich unsere Entenpopulation im Laufe der Zeit ändert. Es ist wie ein Entenzensusnehmer zu sein, nur viel spaßiger und weniger wahrscheinlich, dass ihr von wütenden Wasservögeln verfolgt werdet.

Und da habt ihr es, Leute! Ihr habt gerade eure ersten Schritte in die Welt der Java-Hashtabellen gemacht. Erinnert euch, Übung macht den Meister, also habt keine Angst, mit euren eigenen Enten... Ich meine, Datenkollektionen zu experimentieren. Happy coding!

Credits: Image by storyset