Java WeakHashMap

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

Die WeakHashMapKlasse des Java-Sammlungsframeworks bietet die Funktion der Datenstruktur der Hash-Tabelle…

Es implementiert die Map-Schnittstelle.

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

Das Objekt eines schwachen Referenztyps kann in Java als Müll gesammelt werden, wenn die Referenz nicht mehr im Programm verwendet wird.

Lassen Sie uns zuerst lernen, eine schwache Hash-Map 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 java.util.WeakHashMapzuerst das Paket importieren . Sobald wir das Paket importiert haben, können wir hier schwache Hashmaps in Java erstellen.

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

Im obigen Code haben wir eine schwache Hashmap mit dem Namen numbers erstellt.

Hier,

  • Schlüssel - eine eindeutige Kennung, mit der jedes Element (Wert) in einer Karte zugeordnet wird
  • Wert - Elemente, die durch Schlüssel in einer Karte verknüpft sind

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

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

Standardkapazität und Lastfaktor

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

 // WeakHashMap with default capacity and load factor WeakHashMap numbers1 = new WeakHashMap();

Standardmäßig,

  • Die Kapazität der Karte beträgt 16
  • Der Lastfaktor beträgt 0,75

Unterschiede zwischen HashMap und WeakHashMap

Lassen Sie uns die Implementierung einer schwachen Hashmap in Java sehen.

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of numbers WeakHashMap 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: (Vier = 4, Zwei = 2) WeakHashMap nach Speicherbereinigung: (Vier)

Wie wir sehen können, wird der Schlüssel entfernt, wenn der Schlüssel zwei einer schwachen Hashmap auf gesetzt ist nullund eine Speicherbereinigung durchführt.

Es ist , weil im Gegensatz zu Hashmaps, Schlüssel schwacher Hashmaps von sind schwach Referenztyp. Dies bedeutet, dass der Eintrag einer Karte vom Garbage Collector entfernt wird, wenn der Schlüssel für diesen Eintrag nicht mehr verwendet wird. Dies ist nützlich, um Ressourcen zu sparen.

Lassen Sie uns nun dieselbe Implementierung in einer Hashmap sehen.

 import java.util.HashMap; class Main ( public static void main(String() args) ( // Creating HashMap of even numbers HashMap 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: (Vier = 4, Zwei = 2) HashMap nach Speicherbereinigung: (Vier = 4, Zwei = 2)

Wenn der zweite Schlüssel der Hashmap auf " nullGarbage Collection" gesetzt ist und eine Speicherbereinigung durchführt, wird der Schlüssel hier nicht entfernt.

Dies liegt daran, dass im Gegensatz zu schwachen Hashmaps die Schlüssel von Hashmaps vom starken Referenztyp sind . Dies bedeutet, dass der Eintrag einer Karte vom Garbage Collector nicht entfernt wird, obwohl der Schlüssel zu diesem Eintrag nicht mehr verwendet wird.

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

Erstellen von WeakHashMap aus anderen Karten

Hier erfahren Sie, wie Sie aus anderen Karten eine schwache Hashmap erstellen können.

 import java.util.HashMap; import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating a hashmap of even numbers HashMap 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 numbers = new WeakHashMap(evenNumbers); System.out.println("WeakHashMap: " + numbers); ) )

Ausgabe

 HashMap: (Zwei = 2) WeakHashMap: (Zwei = 2)

Methoden von WeakHashMap

Die WeakHashMapKlasse bietet Methoden, mit denen wir verschiedene Operationen auf der Karte ausführen können.

Fügen Sie Elemente in WeakHashMap ein

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

Beispielsweise,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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 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 mit geraden Zahlen: (Vier = 4, Zwei = 2) WeakHashMap mit Zahlen: (Zwei = 2, Vier = 4, Eins = 1)

Greifen Sie auf WeakHashMap-Elemente zu

1. Using entrySet(), keySet() and values()

  • entrySet() - returns a set of all the key/value mapping of the map
  • keySet() - returns a set of all the keys of the map
  • values() - returns a set of all the values of the map

For example,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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()); ) )

Output

 WeakHashMap: (Two=2, One=1) Key/Value mappings: (Two=2, One=1) Keys: (Two, One) Values: (1, 2)

2. Using get() and getOrDefault()

  • get() - Returns the value associated with the specified key. Returns null if the key is not found.
  • getOrDefault() - Returns the value associated with the specified key. Returns the specified default value if the key is not found.

For example,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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); ) )

Output

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

Remove WeakHashMap Elements

  • remove(key) - returns and removes the entry associated with the specified key from the map
  • remove(key, value) - removes the entry from the map only if the specified key mapped to the specified value and return a boolean value

For example,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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); ) )

Output

WeakHashMap: (Zwei = 2, Eins = 1) Entfernter Wert: 2 Wird der Eintrag (Eins = 3) entfernt? Falsch Aktualisierte WeakHashMap: (Eins = 1)

Andere Methoden von WeakHashMap

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

Weitere Informationen finden Sie unter Java WeakHashMap (offizielle Java-Dokumentation).

Interessante Beiträge...