Java-WeakHashMap

In diesem Tutorial lernen wir Java WeakHashMap und seine Operationen anhand von Beispielen kennen. Wir werden auch die Unterschiede zwischen WeakHashMap und HashMap

kennenlernen

Der WeakHashMap Klasse des Java Collections Framework bietet die Funktion der Hash-Tabellen-Datenstruktur..

Es implementiert die Map-Schnittstelle.

Hinweis :Schlüssel der schwachen Hashmap sind von der WeakReference Typ.

Das Objekt eines schwachen Referenztyps kann in Java von der Garbage Collection erfasst werden, wenn die Referenz nicht mehr im Programm verwendet wird.

Lassen Sie uns zuerst lernen, eine schwache Hash-Karte zu erstellen. Dann werden wir lernen, wie es sich von einer Hashmap unterscheidet.

Erstellen Sie eine WeakHashMap

Um eine schwache Hashmap zu erstellen, müssen wir den java.util.WeakHashMap importieren Paket zuerst. Sobald wir das Paket importiert haben, können wir wie folgt schwache Hashmaps in Java erstellen.

//WeakHashMap creation with capacity 8 and load factor 0.6
WeakHashMap<Key, Value> numbers = new WeakHashMap<>(8, 0.6);

Im obigen Code haben wir eine schwache Hashmap namens numbers erstellt .

Hier,

Schlüssel - eine eindeutige Kennung, die verwendet wird, um jedes Element (Wert) in einer Zuordnung zuzuordnen
Wert - Elemente, die durch Schlüssel in einer Karte verknüpft sind

Beachten Sie den Teil new WeakHashMap<>(8, 0.6) . Hier ist der erste Parameter Kapazität und der zweite Parameter ist loadFactor .

Kapazität - Die Kapazität dieser Karte beträgt 8. Das heißt, sie kann 8 Einträge speichern.
loadFactor - Der Ladefaktor dieser Karte beträgt 0,6. Das heißt, immer wenn unsere Hash-Tabelle zu 60 % gefüllt ist, werden die Einträge in eine neue Hash-Tabelle verschoben, die doppelt so groß ist wie die ursprüngliche Hash-Tabelle.

Standardkapazität und Ladefaktor

Es ist möglich, eine schwache Hashmap zu erstellen, ohne deren Kapazität und Lastfaktor zu definieren. Zum Beispiel

// WeakHashMap with default capacity and load factor
WeakHashMap<Key, Value> numbers1 = new WeakHashMap<>();

Standardmäßig

Die Kapazität der Karte beträgt 16
der Ladefaktor beträgt 0,75

Unterschiede zwischen HashMap und WeakHashMap

Sehen wir uns die Implementierung einer schwachen Hashmap in Java an.

import java.util.WeakHashMap;

class Main {
    public static void main(String[] args) {
        // Creating WeakHashMap of numbers
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();

        String two = new String("Two");
        Integer twoValue = 2;
        String four = new String("Four");
        Integer fourValue = 4;

        // Inserting elements
        numbers.put(two, twoValue);
        numbers.put(four, fourValue);
        System.out.println("WeakHashMap: " + numbers);

        // Make the reference null
        two = null;

        // Perform garbage collection
        System.gc();

        System.out.println("WeakHashMap after garbage collection: " + numbers);
    }
}

Ausgabe

WeakHashMap: {Four=4, Two=2}
WeakHashMap after garbage collection: {Four}

Wie wir sehen können, wenn der Schlüssel zwei einer schwachen Hashmap ist auf null gesetzt und Garbage Collection durchführen, wird der Schlüssel entfernt.

Dies liegt daran, dass Schlüssel schwacher Hashmaps im Gegensatz zu Hashmaps eine schwache Referenz sind Typ. Das bedeutet, dass der Eintrag einer Karte vom Garbage Collector entfernt wird, wenn der Schlüssel zu diesem Eintrag nicht mehr verwendet wird. Dies ist nützlich, um Ressourcen zu sparen.

Sehen wir uns nun dieselbe Implementierung in einer Hashmap an.

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // Creating HashMap of even numbers
        HashMap<String, Integer> numbers = new HashMap<>();

        String two = new String("Two");
        Integer twoValue = 2;
        String four = new String("Four");
        Integer fourValue = 4;

        // Inserting elements
        numbers.put(two, twoValue);
        numbers.put(four, fourValue);
        System.out.println("HashMap: " + numbers);

        // Make the reference null
        two = null;

        // Perform garbage collection
        System.gc();

        System.out.println("HashMap after garbage collection: " + numbers);
    }
}

Ausgabe

HashMap: {Four=4, Two=2}
HashMap after garbage collection: {Four=4, Two=2}

Hier, wenn die Taste zwei der Hashmap ist auf null gesetzt und Garbage Collection durchführen, wird der Schlüssel nicht entfernt.

Dies liegt daran, dass Schlüssel von Hashmaps im Gegensatz zu schwachen Hashmaps eine starke Referenz sind Typ. Das bedeutet, dass der Eintrag einer Zuordnung nicht vom Garbage Collector entfernt wird, obwohl der Schlüssel zu diesem Eintrag nicht mehr verwendet wird.

Hinweis :Alle Funktionalitäten von Hashmaps und schwachen Hashmaps sind ähnlich, außer dass die Schlüssel einer schwachen Hashmap eine schwache Referenz sind, während die Schlüssel einer Hashmap eine starke Referenz sind.

WeakHashMap aus anderen Maps erstellen

So können wir eine schwache Hashmap aus anderen Maps erstellen.

import java.util.HashMap;
import java.util.WeakHashMap;

class Main {
    public static void main(String[] args) {
        // Creating a hashmap of even numbers
        HashMap<String, Integer> evenNumbers = new HashMap<>();

        String two = new String("Two");
        Integer twoValue = 2;
        evenNumbers.put(two, twoValue);
        System.out.println("HashMap: " + evenNumbers);

        // Creating a weak hash map from other hashmap
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>(evenNumbers);

        System.out.println("WeakHashMap: " + numbers);
    }
}

Ausgabe

HashMap: {Two=2}
WeakHashMap: {Two=2}

WeakHashMap-Methoden

Die WeakHashMap Die Klasse stellt Methoden bereit, mit denen wir verschiedene Operationen auf der Karte ausführen können.

Elemente in WeakHashMap einfügen

put() - fügt die angegebene Schlüssel/Wert-Zuordnung in die Zuordnung ein
putAll() - fügt alle Einträge aus der angegebenen Map in diese Map ein
putIfAbsent() - fügt die angegebene Schlüssel/Wert-Zuordnung in die Map ein, wenn der angegebene Schlüssel nicht in der Map vorhanden ist

Zum Beispiel

import java.util.WeakHashMap;

class Main {
    public static void main(String[] args) {
        // Creating WeakHashMap of even numbers
        WeakHashMap<String, Integer> evenNumbers = new WeakHashMap<>();

        String two = new String("Two");
        Integer twoValue = 2;

        // Using put()
        evenNumbers.put(two, twoValue);

        String four = new String("Four");
        Integer fourValue = 4;

        // Using putIfAbsent()
        evenNumbers.putIfAbsent(four, fourValue);
        System.out.println("WeakHashMap of even numbers: " + evenNumbers);

        //Creating WeakHashMap of numbers
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();

        String one = new String("One");
        Integer oneValue = 1;
        numbers.put(one, oneValue);

        // Using putAll()
        numbers.putAll(evenNumbers);
        System.out.println("WeakHashMap of numbers: " + numbers);
    }
}

Ausgabe

WeakHashMap of even numbers: {Four=4, Two=2}
WeakHashMap of numbers: {Two=2, Four=4, One=1}

Zugriff auf WeakHashMap-Elemente

1. Mit entrySet(), keySet() und values()

entrySet() - gibt einen Satz aller Schlüssel/Wert-Mappings der Map zurück
keySet() - gibt einen Satz aller Schlüssel der Karte zurück
values() - gibt einen Satz aller Werte der Karte zurück

Zum Beispiel

import java.util.WeakHashMap;

class Main {
    public static void main(String[] args) {
        // Creating WeakHashMap of even numbers
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();

        String one = new String("One");
        Integer oneValue = 1;
        numbers.put(one, oneValue);

        String two = new String("Two");
        Integer twoValue = 2;
        numbers.put(two, twoValue);

        System.out.println("WeakHashMap: " + numbers);

        // Using entrySet()
        System.out.println("Key/Value mappings: " + numbers.entrySet());

        // Using keySet()
        System.out.println("Keys: " + numbers.keySet());

        // Using values()
        System.out.println("Values: " + numbers.values());
    }
}

Ausgabe

WeakHashMap: {Two=2, One=1}
Key/Value mappings: [Two=2, One=1]
Keys: [Two, One]
Values: [1, 2]

2. Verwendung von get() und getOrDefault()

get() - Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Gibt null zurück wenn der Schlüssel nicht gefunden wird.
getOrDefault() - Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Gibt den angegebenen Standardwert zurück, wenn der Schlüssel nicht gefunden wird.

Zum Beispiel

import java.util.WeakHashMap;

class Main {
    public static void main(String[] args) {
        // Creating WeakHashMap of even numbers
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();

        String one = new String("One");
        Integer oneValue = 1;
        numbers.put(one, oneValue);

        String two = new String("Two");
        Integer twoValue = 2;
        numbers.put(two, twoValue);

        System.out.println("WeakHashMap: " + numbers);

        // Using get()
        int value1 = numbers.get("Two");
        System.out.println("Using get(): " + value1);

        // Using getOrDefault()
        int value2 = numbers.getOrDefault("Four", 4);
        System.out.println("Using getOrDefault(): " + value2);

    }
}

Ausgabe

WeakHashMap: {Two=2, One=1}
Using get(): 2
Using getOrDefault(): 4

WeakHashMap-Elemente entfernen

remove(key) - gibt den mit dem angegebenen Schlüssel verknüpften Eintrag aus der Map zurück und entfernt ihn
remove(key, value) - Entfernt den Eintrag nur dann aus der Zuordnung, wenn der angegebene Schlüssel dem angegebenen Wert zugeordnet ist, und gibt einen booleschen Wert zurück

Zum Beispiel

import java.util.WeakHashMap;

class Main {
    public static void main(String[] args) {
        // Creating WeakHashMap of even numbers
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();

        String one = new String("One");
        Integer oneValue = 1;
        numbers.put(one, oneValue);

        String two = new String("Two");
        Integer twoValue = 2;
        numbers.put(two, twoValue);

        System.out.println("WeakHashMap: " + numbers);

        // Using remove() with single parameter
        int value = numbers.remove("Two");
        System.out.println("Removed value: " + value);

        // Using remove() with 2 parameters
        boolean result = numbers.remove("One", 3);
        System.out.println("Is the entry {One=3} removed? " + result);

        System.out.println("Updated WeakHashMap: " + numbers);
    }
}

Ausgabe

WeakHashMap: {Two=2, One=1}
Removed value: 2
Is the entry {One=3} removed? False
Updated WeakHashMap: {One=1}

Andere WeakHashMap-Methoden

Methode	Beschreibung
`clear()`	Entfernt alle Einträge aus der Karte
`containsKey()`	Überprüft, ob die Map den angegebenen Schlüssel enthält und gibt einen booleschen Wert zurück
`containsValue()`	Überprüft, ob die Karte den angegebenen Wert enthält und gibt einen booleschen Wert zurück
`size()`	Gibt die Größe der Karte zurück
`isEmpty()`	Überprüft, ob die Map leer ist und gibt einen booleschen Wert zurück

Um mehr zu erfahren, besuchen Sie Java WeakHashMap (offizielle Java-Dokumentation).

Java LinkedHashMap Java-EnumMap

Java