Java Dictionary Klasse: Ein Leitfaden für Anfänger

Einführung

Hallo dort, zukünftige Java-Zauberer! Heute werden wir auf eine aufregende Reise in die Welt der Java-Dictionarys aufbrechen. Jetzt denken Sie vielleicht, "Dictionary? Ist das nicht etwas, das ich zum Nachschlagen von Wörtern verwende?" Nun, Sie haben nicht falsch, aber in der Programmierwelt sind Dictionarys ein bisschen unterschiedlich und unglaublich nützlich!

In Java ist ein Dictionary wie eine magische Box, in der Sie Paare von Dingen speichern können. Stellen Sie sich vor, Sie haben eine Schuhbox, und jedes Schuhpaar hat eine passende Socke. Das Dictionary funktioniert ähnlich – Sie legen einen "Schlüssel" (wie der Schuh) hinein, und es gibt Ihnen einen "Wert" (wie die passende Socke) zurück. Cool, nicht wahr?

Lassen Sie uns einsteigen und sehen, wie wir dieses leistungsfähige Werkzeug in unseren Java-Abenteuern verwenden können!

Klassendeklaration

Zuerst das Erste, lassen Sie uns sehen, wie wir ein Dictionary in Java deklarieren:

import java.util.Dictionary;

public class MeinDictionary extends Dictionary<Integer, String> {
// Ihr Code hier
}

Nun, lassen Sie sich das nicht abschrecken! Lassen Sie uns das aufteilen:

1. Wir importieren die Dictionary-Klasse aus dem Java-Utility-Paket.
2. Wir erstellen unsere eigene Klasse mit dem Namen MeinDictionary.
3. Wir sagen, dass unser Dictionary Integer als Schlüssel und Strings als Werte verwenden wird.

Stellen Sie sich das vor, als ob wir eine spezielle Box erstellen würden, in der wir Zahlen (Integer) auf der Außenseite und Wörter (String) auf der Innenseite platzieren.

Klassenkonstruktoren

Nun, da wir unsere Dictionary-Box haben, lassen Sie uns sehen, wie wir sie erstellen können:

public MeinDictionary() {
// Konstruktorcode hier
}

Dies wird als Konstruktor bezeichnet. Es ist wie die Fabrik, die unsere Dictionary-Box baut. Wir können sie für jetzt leer lassen, da Java eine Standardmöglichkeit zur Erstellung unseres Dictionarys bietet.

Klassenmethoden

Hier geschieht die Magie! Dictionarys kommen mit einigen eingebauten Superkräften (Methoden), die wir verwenden können. Lassen Sie uns einige ansehen:

@Override
public int size() {
// Liefert die Anzahl der Schlüssel-Wert-Paare
}

@Override
public boolean isEmpty() {
// Überprüft, ob das Dictionary leer ist
}

@Override
public String get(Object key) {
// Holt den Wert, der mit dem Schlüssel verbunden ist
}

@Override
public String put(Integer key, String value) {
// Fügt ein neues Schlüssel-Wert-Paar hinzu oder aktualisiert ein bestehendes
}

@Override
public String remove(Object key) {
// Entfernt ein Schlüssel-Wert-Paar
}

Keine Sorge wegen dem @Override für jetzt. Es ist nur, dass wir Java mitteilen, dass wir unsere eigene Version dieser Methoden verwenden.

Lassen Sie uns das aufteilen:

1. size(): Zählt, wie viele Paare in unserem Dictionary sind.
2. isEmpty(): Überprüft, ob unser Dictionary leer ist (wie überprüfen, ob unsere Schuhbox Schuhe enthält).
3. get(Object key): Findet den Wert für einen gegebenen Schlüssel (wie finden die Socke, die einem Schuh entspricht).
4. put(Integer key, String value): Fügt ein neues Paar hinzu oder aktualisiert ein bestehendes.
5. remove(Object key): Nimmt ein Paar aus unserem Dictionary heraus.

Vererbte Methoden

Unser Dictionary erbt auch einige Methoden von seinen Elternklassen. Stellen Sie sich diese als Bonusfunktionen vor, die mit unserer Dictionary-Box kommen:

Methode	Beschreibung
clone()	Erstellt eine Kopie des Dictionarys
equals(Object obj)	Überprüft, ob zwei Dictionarys gleich sind
hashCode()	Generiert einen eindeutigen Code für das Dictionary
toString()	Konvertiert das Dictionary in einen String
notify()	Weckt einen Thread auf, der auf dieses Dictionary wartet
notifyAll()	Weckt alle Threads auf, die auf dieses Dictionary warten
wait()	Lässt den aktuellen Thread warten

Diese Methoden können in fortgeschritteneren Programmierszenarien sehr hilfreich sein.

Hinzufügen eines Mappings zu Dictionary von Integer, Integer Beispiel

Nun, lassen Sie uns all diese Kenntnisse in die Praxis umsetzen! Wir erstellen ein Dictionary, das Schüler-IDs (Integers) auf ihre Alter (auch Integers) abbildet:

import java.util.Dictionary;
import java.util.Hashtable;

public class StudentenAlter {
public static void main(String[] args) {
// Erstellen eines neuen Dictionarys
Dictionary<Integer, Integer> studentenAlter = new Hashtable<>();

// Hinzufügen einiger Schüler-IDs und Alter
studentenAlter.put(1001, 18);
studentenAlter.put(1002, 19);
studentenAlter.put(1003, 20);

// Drucken des Dictionarys
System.out.println("Schüler Alter: " + studentenAlter);

// Holen des Alters eines Schülers
int studentId = 1002;
int alter = studentenAlter.get(studentId);
System.out.println("Alter des Schülers mit ID " + studentId + ": " + alter);

// Entfernen eines Schülers
studentenAlter.remove(1001);

// Überprüfen, ob das Dictionary leer ist
System.out.println("Ist das Dictionary leer? " + studentenAlter.isEmpty());

// Holen der Größe des Dictionarys
System.out.println("Anzahl der Schüler: " + studentenAlter.size());
}
}

Lassen Sie uns das aufteilen:

1. Wir erstellen ein neues Dictionary namens studentenAlter.
2. Wir fügen drei Schüler mit ihren IDs und Alter hinzu.
3. Wir drucken das gesamte Dictionary aus.
4. Wir holen und drucken das Alter des Schülers mit der ID 1002.
5. Wir entfernen den Schüler mit der ID 1001.
6. Wir überprüfen, ob das Dictionary leer ist (es ist nicht!).
7. Schließlich drucken wir aus, wie viele Schüler noch in unserem Dictionary sind.

Wenn Sie diesen Code ausführen, sehen Sie alle diese Operationen in Aktion!

Und da haben Sie es, Leute! Sie haben gerade Ihre ersten Schritte in die Welt der Java-Dictionarys gemacht. Denken Sie daran, Praxis macht den Meister, also lassen Sie sich nicht von dem Versuch, verschiedene Schlüssel und Werte zu experimentieren, abschrecken. Wer weiß? Vielleicht werden Sie die nächste großartige App mit Dictionarys erstellen!

Happy coding, und möge Ihr Dictionary immer gut organisiert sein!

Credits: Image by storyset