Java WeakHashMap

In diesem Tutorial werden wir mit Beispielen lernen, wie man Java WeakHashMap und seine Operationen verwendet. Wir werden auch die Unterschiede zwischen WeakHashMap und HashMap verstehen

Die Klasse WeakHashMap der Java Collection Framework bietet die Funktionen der Hash-Table-Datenstruktur.

es implementiertMap-Schnittstelle.

注意:WeakHashMap gehört zuWeakReferenceTyp.

Objekte des Typs WeakReference können in Java recycelt werden, wenn die Referenz nicht mehr im Programm verwendet wird.

Lassen Sie uns zunächst lernen, wie man eine WeakHashMap erstellt. Dann werden wir die Unterschiede zwischen ihr und HashMap verstehen.

Erstellen Sie eine WeakHashMap

Um eine WeakHashMap zu erstellen, müssen wir zunächst das Paket java.util.WeakHashMap importieren. Nach dem Import des Pakets kann eine WeakHashMap in Java wie folgt erstellt werden.

//Erstellen Sie eine WeakHashMap mit der Kapazität8，Lastfaktor ist 0.6
WeakHashMap<Key,　Value>　numbers　=　new　WeakHashMap<>(8,　0.6);

Im obigen Code haben wir eine WeakHashMap namens numbers erstellt.

hier,

• Schlüssel - wird ein einzigartiger Identifikator verwendet, um jedes Element (Wert) im Mapping zu verknüpfen

• Value - Mit der zugehörigen Elemente im Mapping

Beachten Sie new WeakHashMap<>(8,0.6)dieser Teil. Hierbei ist der erste Parameter capacity, der zweite Parameter loadFactor.

• capacity - Die Kapazität dieses Maps ist8Das bedeutet, dass es speichern kann8Einträge.

• loadFactor- Der Lastfaktor dieses Maps ist 0.6Das bedeutet, dass unser Hash-Table gefüllt wird60％, der Eintrag wird in den neuen Hash-Table übertragen, die die Größe der ursprünglichen Hash-Table verdoppelt.

Standardkapazität und Lastfaktor

Eine WeakHashMap kann ohne die Definition ihrer Kapazität und des Lastfaktors erstellt werden. Zum Beispiel,

//具有默认容量和负载因子的WeakHashMap
WeakHashMap<Key, Value> numbers1　= new WeakHashMap<>();

默认，

• map的容量将为 16

• 负载因子将为0.75

HashMap和WeakHashMap之间的区别

让我们看看Java中弱哈希表的实现。

import　java.util.WeakHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　创建名称为numbers的WeakHashMap
　　　　　　　　WeakHashMap<String,　Integer>　numbers　=　new　WeakHashMap<>();
　　　　　　　　String　two　=　new　String("Two");
　　　　　　　　Integer　twoValue　=　2;
　　　　　　　　evenNumbers.put(two, twoValue);
　　　　　　　　String four = new String("Four");　4;
　　　　　　　　//插入元素
　　　　　　　　numbers.put(two,　twoValue);
　　　　　　　　numbers.put(four, fourValue);
　　　　　　　　System.out.println("WeakHashMap:　")　+　numbers);
　　　　　　　　//null引用
　　　　　　　　two = null;
　　　　　　　　//执行垃圾回收
　　　　　　　　System.gc();
　　　　　　　　System.out.println("Weak垃圾回收后的HashMap　:　"　+　numbers);
　　　　}
}

Ausgaberesultat

WeakHashMap:　{Four=4Die WeakHashMap für die geraden Zahlen: {Four=2}
Weak垃圾回收后的HashMap　:　{Four}

如我们所见，当two弱哈希图的键设置为null并执行垃圾回收时，该键将被删除。

这是因为与散列表不同，弱散列表的键属于弱引用类型。这意味着如果不再使用映射条目，则垃圾收集器将删除该条目。这对于节省资源很有用。

现在让我们在哈希图中查看相同的实现。

import java.util.HashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//创建偶数HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　String　two　=　new　String("Two");
　　　　　　　　Integer　twoValue　=　2;
　　　　　　　　evenNumbers.put(two, twoValue);
　　　　　　　　String four = new String("Four");　4;
　　　　　　　　//插入元素
　　　　　　　　numbers.put(two,　twoValue);
　　　　　　　　numbers.put(four, fourValue);
　　　　　　　　System.out.println("HashMap: "　+　numbers);
　　　　　　　　//使引用为空
　　　　　　　　two = null;
　　　　　　　　//执行垃圾回收
　　　　　　　　System.gc();
　　　　　　　　System.out.println("垃圾回收后的HashMap　:　"　+　numbers);
　　　　}
}

Ausgaberesultat

HashMap:　{Four=4Die WeakHashMap für die geraden Zahlen: {Four=2}
垃圾回收后的HashMap　:　{Four=4Die WeakHashMap für die geraden Zahlen: {Four=2}

在此，将哈希表的键two设置为null并执行垃圾回收时，不会删除该键。

这是因为与弱hashmap不同，hashmap的键具有强引用类型。这意味着即使映射条目的键不再被使用，该条目也不会被垃圾回收器删除。

注意：hashmap和弱hashmap的所有功能都是相似的，除了弱hashmap的键是弱引用，而hashmap的键是强引用。

从其他映射创建WeakHashMap

这是我们可以从其他map创建弱哈希表的方法。

import java.util.HashMap;
import　java.util.WeakHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　创建偶数的hashmap　
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　String　two　=　new　String("Two");
　　　　　　　　Integer　twoValue　=　2;
　　　　　　　　Verwenden Sie put()
　　　　　　　　System.out.println("HashMap: "　+　System.out.println("Die WeakHashMap für die geraden Zahlen: " );
　　　　　　　　//　从其他哈希映射创建弱哈希映射　
　　　　　　　　Erstellen Sie eine WeakHashMap aus anderen Hash-Mappings
　　　　　　　　System.out.println("WeakHashMap:　")　+　numbers);
　　　　}
}

Ausgaberesultat

WeakHashMap<String, Integer> numbers = new WeakHashMap<>(evenNumbers);2}
WeakHashMap: {Two=2}

HashMap: {Two=

Methoden der WeakHashMap

Die WeakHashMap-Klasse bietet Methoden, um verschiedene Operationen auf die Abbildung auszuführen.

• Fügt das Element in die WeakHashMap ein - put()/Fügt den angegebenen Schlüssel hinzu

• Wertzuordnung wird in das Map eingefügt - putAll()

• Fügt alle Einträge aus der angegebenen Zuordnung in dieses Map ein - putIfAbsent()/Fügt dem Map den angegebenen Schlüssel hinzu, wenn der Schlüssel im Map nicht existiert

例如，

import　java.util.WeakHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　创建偶数WeakHashMap　
　　　　　　　　Wertzuordnung wird in das Map eingefügt
　　　　　　　　String　two　=　new　String("Two");
　　　　　　　　Integer　twoValue　=　2;
　　　　　　　　//　WeakHashMap<String, Integer> evenNumbers = new WeakHashMap<>();
　　　　　　　　Verwenden Sie put()
　　　　　　　　evenNumbers.put(two, twoValue);
　　　　　　　　String four = new String("Four");　4;
　　　　　　　　//　Integer fourValue =
　　　　　　　　Verwenden Sie putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent(four, fourValue);　+　System.out.println("Die WeakHashMap für die geraden Zahlen: " );
　　　　　　　　//evenNumbers);
　　　　　　　　WeakHashMap<String,　Integer>　numbers　=　new　WeakHashMap<>();
　　　　　　　　String　one　=　new　String("One");
　　　　　　　　Integer　oneValue　=　1;
　　　　　　　　numbers.put(one,　oneValue);
　　　　　　　　//　Erstellen Sie eine WeakHashMap namens numbers
　　　　　　　　Verwenden Sie putAll()
　　　　　　　　numbers.putAll(evenNumbers);　+　numbers);
　　　　}
}

Ausgaberesultat

System.out.println("Die Zahlen der WeakHashMap: " );4Die WeakHashMap für die geraden Zahlen: {Four=2}
, Two=2Die Zahlen der WeakHashMap: {Two=4, One=1}

, Four=

1.Verwenden Sie entrySet(), keySet() und values(), um auf die Elemente der WeakHashMap zuzugreifen

• entrySet() - Gibt eine Sammlung aller Schlüssel zurück/Sammlung der Wertzuordnungen

• keySet() - Gibt die Sammlung aller Schlüssel des Maps zurück

• values() - Gibt die Sammlung aller Werte des Maps zurück

例如，

import　java.util.WeakHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　创建偶数WeakHashMap　
　　　　　　　　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);
　　　　　　　　//　Verwenden Sie entrySet()
　　　　　　　　System.out.println("Key/Wertzuordnung: "　+　numbers.entrySet());
　　　　　　　　//　Verwenden Sie keySet()
　　　　　　　　System.out.println("Keys: " );　+　numbers.keySet());
　　　　　　　　//　使用　values()}
　　　　　　　　System.out.println("Werte:　")　+　numbers.values());
　　　　}
}

Ausgaberesultat

WeakHashMap: {Two=2, One=1}
Schlüssel/Wertzuordnung:　[Two=2, One=1]
Schlüssel:　[Two,　One]
Werte:　[1,　2]

2.使用get()和getOrDefault()

• get()- 返回与指定键关联的值。如果找不到键，则返回null。

• getOrDefault() - 返回与指定键关联的值。如果找不到键，则返回指定的默认值。

例如，

import　java.util.WeakHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　创建偶数WeakHashMap　
　　　　　　　　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);
　　　　　　　　//　使用　get()
　　　　　　　　int　value1　=　numbers.get("Two");
　　　　　　　　System.out.println("使用　get()　方法:　")　+　value1);
　　　　　　　　//　使用　getOrDefault()
　　　　　　　　int　value2　=　numbers.getOrDefault("Four",　4);
　　　　　　　　System.out.println("使用　getOrDefault()　方法:　")　+　value2);
　　　　}
}

Ausgaberesultat

WeakHashMap: {Two=2, One=1}
使用　get()　方法:　2
使用　getOrDefault()　方法:　4

删除WeakHashMap元素

• remove(key) - 返回并从映射中删除与指定键相关联的项。

• remove(key, value) - 只有当指定的键映射到指定的值并返回布尔值时，才从映射中删除条目

例如，

import　java.util.WeakHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　创建偶数WeakHashMap　
　　　　　　　　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);
　　　　　　　　//　Verwenden Sie remove() und geben Sie1Parameter
　　　　　　　　int　value　=　numbers.remove("Two");
　　　　　　　　System.out.println("删除值：　")　+　value);
　　　　　　　　//　Verwenden Sie remove() und geben Sie2Parameter
　　　　　　　　boolean result = numbers.remove("One",　3);
　　　　　　　　System.out.println("Eintrag {One=",3} wurde gelöscht? \　+　result);
　　　　　　　　System.out.println("Aktualisierte WeakHashMap: ",　+　numbers);
　　　　}
}

Ausgaberesultat

WeakHashMap: {Two=2, One=1}
Entfernen Sie den Wert:　2
Eintrag {One=3} wurde gelöscht? False
Aktualisierte WeakHashMap: {One=1}

Andere Methoden von WeakHashMap