Java WeakHashMap

Dans ce tutoriel, nous allons apprendre Java WeakHashMap et ses opérations à l'aide d'exemples. Nous allons également comprendre les différences entre WeakHashMap et HashMap

La classe WeakHashMap de la Java Collection Framework fournit les fonctionnalités de structure de données tableau de hachage.

Il implémenteInterface Map.

注意Les hashmap de clé faible appartiennent àWeakReferenceType.

Les objets de type référence faible peuvent être collectés par le garbage collector en Java si cette référence n'est plus utilisée dans le programme.

Permettons-nous d'apprendre à créer une carte de hachage faible. Ensuite, nous verrons les différences entre cette carte et HashMap.

Créer une WeakHashMap

Pour créer un tableau de hachage faible, nous devons d'abord importer le paquet java.util.WeakHashMap. Après avoir importé le paquet, vous pouvez créer un tableau de hachage faible en Java en utilisant les méthodes suivantes.

//Créer une WeakHashMap, avec une capacité de8, avec un facteur de charge de 0.6
WeakHashMap<Key, Value> numbers = new WeakHashMap<>(8, 0.6);

Dans le code ci-dessus, nous avons créé une WeakHashMap nommée numbers.

Ici,

• Clé - Utilisé pour identifier de manière unique chaque élément (valeur) de la carte

• Value - Les éléments associés à la clé dans la carte

Attention new WeakHashMap<>(8,0.6) cette partie. Ici, le premier paramètre est capacity, le deuxième paramètre est loadFactor.

• capacity - La capacité de cette carte est8Cela signifie qu'elle peut stocker8éléments.

• loadFactor- Le facteur de charge de cette carte est de 0.6Cela signifie que tant que notre tableau de hachage est rempli60%, les entrées seront déplacées vers un nouveau tableau de hachage, whose size is twice that of the original hash table.

Capacité par défaut et facteur de charge

Il est possible de créer une WeakHashMap sans définir sa capacité et son facteur de charge. Par exemple,

//具有默认容量和负载因子的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;
　　　　　　　　String ",four" = new String("Four");
　　　　　　　　Integer ",fourValue" =　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);
　　　　}
}

Output result

WeakHashMap: {Four=4, ",Two=",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;
　　　　　　　　String ",four" = new String("Four");
　　　　　　　　Integer ",fourValue" =　4;
　　　　　　　　//插入元素
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　numbers.put(four, fourValue);
　　　　　　　　System.out.println("HashMap: "　+　numbers);
　　　　　　　　//使引用为空
　　　　　　　　two = null;
　　　　　　　　//执行垃圾回收
　　　　　　　　System.gc();
　　　　　　　　System.out.println("垃圾回收后的HashMap : "　+　numbers);
　　　　}
}

Output result

HashMap: {Four=4, ",Two=",2}
垃圾回收后的HashMap : {Four=4, ",Two=",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;
　　　　　　　　evenNumbers.put(two, ",twoValue");
　　　　　　　　System.out.println("HashMap: "　+　evenNumbers);
　　　　　　　　//　从其他哈希映射创建弱哈希映射　
　　　　　　　　WeakHashMap<String, ",Integer"> numbers = new WeakHashMap<>(evenNumbers);
　　　　　　　　System.out.println("WeakHashMap : "
　+　numbers);
　　　　}
}

Output result

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

WeakHashMap的方法

WeakHashMap类提供了允许我们对映射执行各种操作的方法。

• put() - 将指定的键/

• putAll() -

• putIfAbsent() - 如果map中不存在指定的键，则将指定的键/值映射插入到map中

Par exemple,

import java.util.WeakHashMap;
class Main {

　　　　public static void main(String[] args) {

　　　　　　　　//　Créer un WeakHashMap d'entiers pairs　
　　　　　　　　WeakHashMap<String, ",Integer"> evenNumbers = new WeakHashMap<>();
　　　　　　　　String two = new String("Two");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　//　使用 ",put(",
　　　　　　　　evenNumbers.put(two, ",twoValue");
　　　　　　　　String ",four" = new String("Four");
　　　　　　　　Integer ",fourValue" =　4;
　　　　　　　　//　使用 ",putIfAbsent(",
　　　　　　　　evenNumbers.putIfAbsent(four, ",fourValue");
　　　　　　　　System.out.println("偶数的WeakHashMap: ",　+　evenNumbers);
　　　　　　　　//创建名为numbers的WeakHashMap
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String one = new String("One");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　//　使用 ",putAll(",
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("WeakHashMap的数字: ",　+　numbers);
　　　　}
}

Output result

偶数的WeakHashMap: ",{Four=",4, ",Two=",2}
WeakHashMap的数字: ",{Two=",2, ",Four=",4, One=1}

1

• entrySet() - 返回一组所有键/

• keySet() -

• values() - 返回map所有值的集合

Par exemple,

import java.util.WeakHashMap;
class Main {

　　　　public static void main(String[] args) {

　　　　　　　　//　Créer un WeakHashMap d'entiers pairs　
　　　　　　　　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);
　　　　　　　　//　使用 ",entrySet()",
　　　　　　　　System.out.println("Key",/Value ", 映射: ",　+　numbers.entrySet());
　　　　　　　　//　使用 ",keySet()",
　　　　　　　　System.out.println("Keys: ",　+　numbers.keySet());
　　　　　　　　//　Utiliser values()
　　　　　　　　System.out.println("Valeurs : ")　+　numbers.values());
　　　　}
}

Output result

WeakHashMap: {Two=2, One=1}
Clé/Mapping de valeurs : [Two=2, One=1"]
Clés : [Two, One]
Valeurs : [1,　2"]

2.Utiliser get() et getOrDefault()

• get()- Retourner la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, retourner null.

• getOrDefault() - Retourner la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, retourner la valeur par défaut spécifiée.

Par exemple,

import java.util.WeakHashMap;
class Main {

　　　　public static void main(String[] args) {

　　　　　　　　//　Créer un WeakHashMap d'entiers pairs　
　　　　　　　　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);
　　　　　　　　//　Utiliser get()
　　　　　　　　int value1　= numbers.get("Two");
　　　　　　　　System.out.println("Utiliser la méthode get() : "
　+　value1);
　　　　　　　　//　Utiliser getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Four",　4);
　　　　　　　　System.out.println("Utiliser la méthode getOrDefault() : "
　+　value2);
　　　　}
}

Output result

WeakHashMap: {Two=2, One=1}
Utiliser la méthode get() :　2
Utiliser la méthode getOrDefault() :　4

Supprimer l'élément de WeakHashMap

• remove(key) - Retourner et supprimer l'élément associé à la clé spécifiée dans la carte.

• remove(key, value) - Supprimer l'entrée de la carte uniquement si la clé spécifiée est mappée à la valeur spécifiée et retourner la valeur booléenne.

Par exemple,

import java.util.WeakHashMap;
class Main {

　　　　public static void main(String[] args) {

　　　　　　　　//　Créer un WeakHashMap d'entiers pairs　
　　　　　　　　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() and with1number of parameters
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Supprimer la valeur : "
　+　value);
　　　　　　　　//　Using remove() and with2number of parameters
　　　　　　　　boolean result = numbers.remove("One",　3);
　　　　　　　　System.out.println("Entry {One=",3Has been deleted? \　+　result);
　　　　　　　　System.out.println("Updated WeakHashMap: ",　+　numbers);
　　　　}
}

Output result

WeakHashMap: {Two=2, One=1}
Deleted value:　2
Entry {One=3} Has been deleted? False
Updated WeakHashMap: {One=1}

Other methods of WeakHashMap