Übersetzung ins Deutsche

Java WeakHashMap Klasse: Ein Anfänger-Leitfaden

Einführung

Hallo daar, zukünftige Java-Programmierer! Heute werden wir in die faszinierende Welt der WeakHashMap in Java eintauchen. Keine Sorge, wenn du noch nie davon gehört hast – wir beginnen bei den Grundlagen und arbeiten uns nach oben. Am Ende dieses Tutorials wirst du ein WeakHashMap-Experte sein!

Java - WeakHashMap

Was ist eine WeakHashMap?

Stelle dir vor, du organisiert eine große Party und hast eine Gästeliste. Aber diese ist keine normale Gästeliste – es ist eine magische Liste, die automatisch Menschen entfernt, die nicht mehr kommen können. Das ist ziemlich das, was eine WeakHashMap in Java macht, aber mit Objekten anstelle von Partygästen!

Eine WeakHashMap ist eine spezielle Art von Map in Java, die es ermöglicht, dass ihre Schlüssel garbage collected werden, wenn sie nicht mehr in deinem Programm verwendet werden. Dies kann wirklich nützlich sein, wenn du einen Cache erstellen möchtest, der nicht verhindert, dass Objekte gelöscht werden, wenn sie nicht mehr benötigt werden.

Klassendeklaration

Beginnen wir damit, wie man eine WeakHashMap deklariert:

import java.util.WeakHashMap;

public class WeakHashMapBeispiel {
    public static void main(String[] args) {
        WeakHashMap<String, Integer> meineWeakMap = new WeakHashMap<>();
    }
}

In diesem Beispiel erstellen wir eine WeakHashMap, die String-Objekte als Schlüssel und Integer-Objekte als Werte verwendet. Der <String, Integer>-Teil wird "Generics" genannt – es ist, als würde man Java sagen, welche Art von Objekten man in seiner Karte speichern möchte.

Klassenkonstruktoren

WeakHashMap kommt mit vier verschiedenen Konstruktoren. Sehen wir uns jeden von ihnen an:

Standardkonstruktor:
```
WeakHashMap<String, Integer> map1 = new WeakHashMap<>();
```
Dies erstellt eine leere WeakHashMap mit der Standardinitialkapazität (16) und dem Standard-Ladefaktor (0.75).
Konstruktor mit initialer Kapazität:
```
WeakHashMap<String, Integer> map2 = new WeakHashMap<>(100);
```
Dies erstellt eine WeakHashMap mit der angegebenen initialen Kapazität und dem Standard-Ladefaktor.
Konstruktor mit initialer Kapazität und Ladefaktor:
```
WeakHashMap<String, Integer> map3 = new WeakHashMap<>(100, 0.8f);
```
Dies erstellt eine WeakHashMap mit der angegebenen initialen Kapazität und dem Ladefaktor.

Konstruktor mit einer anderen Map:

Map<String, Integer> existierendeMap = new HashMap<>();
existierendeMap.put("Alice", 25);
existierendeMap.put("Bob", 30);
WeakHashMap<String, Integer> map4 = new WeakHashMap<>(existierendeMap);

Dies erstellt eine WeakHashMap mit denselben Zuordnungen wie die angegebene Karte.

Klassenmethoden

WeakHashMap bietet mehrere Methoden zur Manipulation und zum Zugriff auf ihre Inhalte. Hier ist eine Tabelle einiger der am häufigsten verwendeten Methoden:

Methode	Beschreibung
put(K schlüssel, V wert)	Fügt ein Schlüssel-Wert-Paar zur Karte hinzu
get(Object schlüssel)	Ruft den Wert ab, der dem angegebenen Schlüssel zugeordnet ist
remove(Object schlüssel)	Entfernt die Zuordnung für den angegebenen Schlüssel
size()	Liefert die Anzahl der Schlüssel-Wert-Zuordnungen in der Karte
clear()	Entfernt alle Zuordnungen von der Karte
containsKey(Object schlüssel)	Liefert true zurück, wenn die Karte den angegebenen Schlüssel enthält
containsValue(Object wert)	Liefert true zurück, wenn die Karte den angegebenen Wert enthält
isEmpty()	Liefert true zurück, wenn die Karte keine Schlüssel-Wert-Zuordnungen enthält

Sehen wir uns einige dieser Methoden in Aktion an:

WeakHashMap<String, Integer> alterMap = new WeakHashMap<>();

// Hinzufügen von Schlüssel-Wert-Paaren
alterMap.put("Alice", 25);
alterMap.put("Bob", 30);
alterMap.put("Charlie", 35);

// Abrufen eines Wertes
System.out.println("Alters von Alice: " + alterMap.get("Alice")); // Ausgabe: Alters von Alice: 25

// Überprüfen, ob ein Schlüssel existiert
System.out.println("Ist David in der Karte? " + alterMap.containsKey("David")); // Ausgabe: Ist David in der Karte? false

// Entfernen eines Schlüssel-Wert-Paares
alterMap.remove("Bob");
System.out.println("Größe der Karte nach dem Entfernen von Bob: " + alterMap.size()); // Ausgabe: Größe der Karte nach dem Entfernen von Bob: 2

// Leeren der Karte
alterMap.clear();
System.out.println("Ist die Karte leer? " + alterMap.isEmpty()); // Ausgabe: Ist die Karte leer? true

Vererbte Methoden

WeakHashMap erbt Methoden von ihren Elternklassen und Schnittstellen. Hier sind einige der wichtigen vererbten Methoden:

Vererbt von	Methoden
java.util.AbstractMap	clone(), equals(), hashCode(), toString()
java.util.Map	entrySet(), keySet(), values()
java.lang.Object	finalize(), getClass(), notify(), notifyAll(), wait()

Beispiel für das Hinzufügen eines Schlüssel-Wert-Paares zu einer WeakHashMap von Integer, Integer-Paaren

Nunsehen wir uns ein vollständigeres Beispiel für die Verwendung einer WeakHashMap mit Integer-Schlüsseln und -Werten:

import java.util.WeakHashMap;

public class WeakHashMapBeispiel {
    public static void main(String[] args) {
        WeakHashMap<Integer, Integer> quadratMap = new WeakHashMap<>();

        // Hinzufügen von Schlüssel-Wert-Paaren
        for (int i = 1; i <= 5; i++) {
            quadratMap.put(i, i * i);
        }

        System.out.println("Anfangs-Karte: " + quadratMap);

        // Zugriff auf Werte
        System.out.println("Quadrat von 3: " + quadratMap.get(3));

        // Entfernen eines Schlüssel-Wert-Paares
        quadratMap.remove(2);
        System.out.println("Karte nach dem Entfernen von 2: " + quadratMap);

        // Überprüfen, ob ein Schlüssel existiert
        System.out.println("Enthält die Karte 4? " + quadratMap.containsKey(4));

        // Überprüfen, ob ein Wert existiert
        System.out.println("Enthält die Karte den Wert 16? " + quadratMap.containsValue(16));

        // Iteration über die Karte
        System.out.println("Iteration über die Karte:");
        for (Integer schlüssel : quadratMap.keySet()) {
            System.out.println("Schlüssel: " + schlüssel + ", Wert: " + quadratMap.get(schlüssel));
        }
    }
}

Ausgabe

Wenn du diesen Code ausführst, siehst du eine Ausgabe ähnlich dieser:

Anfangs-Karte: {5=25, 4=16, 3=9, 2=4, 1=1}
Quadrat von 3: 9
Karte nach dem Entfernen von 2: {5=25, 4=16, 3=9, 1=1}
Enthält die Karte 4? true
Enthält die Karte den Wert 16? true
Iteration über die Karte:
Schlüssel: 5, Wert: 25
Schlüssel: 4, Wert: 16
Schlüssel: 3, Wert: 9
Schlüssel: 1, Wert: 1

Und das ist es! Du hast gerade deine ersten Schritte in die Welt der WeakHashMap in Java gemacht. Denke daran, die wahre Stärke der WeakHashMap liegt in ihrer Fähigkeit, Schlüssel zu ermöglichen, garbage collected zu werden, wenn sie nicht mehr anderswo in deinem Programm referenziert werden. Dies kann in bestimmten Szenarien unglaublich nützlich sein, wie z.B. bei der Implementierung von Caches oder der Verwaltung von temporären Daten.

Während du deinen Java-Weg fortsetzt, wirst du immer mehr Situationen entdecken, in denen WeakHashMap ein wertvolles Werkzeug in deinem Programmier-Toolbox sein kann. Bleibe dran, erkunde weiter und vor allem, hab Spaß beim Coden!

Credits: Image by storyset