Java WeakHashMap

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

La WeakHashMapclasse du framework de collections Java fournit la fonctionnalité de la structure de données de table de hachage …

Il implémente l'interface Map.

Remarque : les clés du hashmap faible sont du type WeakReference .

L'objet d'un type de référence faible peut être récupéré en Java si la référence n'est plus utilisée dans le programme.

Apprenons d'abord à créer une carte de hachage faible. Ensuite, nous apprendrons en quoi il diffère d'un hashmap.

Créer un WeakHashMap

Afin de créer un hashmap faible, nous devons d'abord importer le java.util.WeakHashMappackage. Une fois que nous importons le package, voici comment créer des hashmaps faibles en Java.

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

Dans le code ci-dessus, nous avons créé une carte de hachage faible nommée nombres.

Ici,

  • Clé - un identifiant unique utilisé pour associer chaque élément (valeur) dans une carte
  • Valeur - éléments associés par des clés dans une carte

Remarquez la pièce new WeakHashMap(8, 0.6). Ici, le premier paramètre est la capacité et le deuxième paramètre est loadFactor .

  • capacité - La capacité de cette carte est 8. Cela signifie qu'elle peut stocker 8 entrées.
  • loadFactor - Le facteur de charge de cette carte est de 0,6. Cela signifie que chaque fois que notre table de hachage est remplie à 60%, les entrées sont déplacées vers une nouvelle table de hachage de deux fois la taille de la table de hachage d'origine.

Capacité par défaut et facteur de charge

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

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

Par défaut,

  • la capacité de la carte sera de 16
  • le facteur de charge sera de 0,75

Différences entre HashMap et WeakHashMap

Voyons l'implémentation d'un hashmap faible en Java.

 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); ) )

Production

 WeakHashMap: (Quatre = 4, Deux = 2) WeakHashMap après le garbage collection: (Quatre)

Comme nous pouvons le voir, lorsque la clé deux d'une carte de hachage faible est définie sur nullet effectue un ramasse-miettes, la clé est supprimée.

C'est parce que contrairement aux hashmaps, les clés des hashmaps faibles sont de type référence faible . Cela signifie que l'entrée d'une carte est supprimée par le garbage collector si la clé de cette entrée n'est plus utilisée. Ceci est utile pour économiser des ressources.

Voyons maintenant la même implémentation dans un hashmap.

 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); ) )

Production

 HashMap: (Quatre = 4, Deux = 2) HashMap après garbage collection: (Quatre = 4, Deux = 2)

Ici, lorsque la clé deux de la table de hachage est définie sur nullet effectue un garbage collection, la clé n'est pas supprimée.

En effet, contrairement aux clés de hashmaps faibles, les clés de hashmaps sont de type référence forte . Cela signifie que l'entrée d'une carte n'est pas supprimée par le ramasse-miettes même si la clé de cette entrée n'est plus utilisée.

Remarque : Toutes les fonctionnalités des hashmaps et des hashmaps faibles sont similaires sauf que les clés d'un hashmap faible sont de référence faible, alors que les clés d'un hashmap sont de référence forte.

Création de WeakHashMap à partir d'autres cartes

Voici comment créer un hashmap faible à partir d'autres cartes.

 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); ) )

Production

 HashMap: (Deux = 2) WeakHashMap: (Deux = 2)

Méthodes de WeakHashMap

La WeakHashMapclasse fournit des méthodes qui nous permettent d'effectuer diverses opérations sur la carte.

Insérer des éléments dans WeakHashMap

  • put() - insère le mappage clé / valeur spécifié dans la carte
  • putAll() - insère toutes les entrées de la carte spécifiée dans cette carte
  • putIfAbsent() - insère le mappage clé / valeur spécifié dans la carte si la clé spécifiée n'est pas présente dans la carte

Par exemple,

 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); ) )

Production

 WeakHashMap de nombres pairs: (Quatre = 4, Deux = 2) WeakHashMap de nombres: (Deux = 2, Quatre = 4, Un = 1)

Accéder aux éléments WeakHashMap

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: (Two = 2, One = 1) Valeur supprimée: 2 L'entrée (One = 3) est-elle supprimée? Faux WeakHashMap mis à jour: (Un = 1)

Autres méthodes de WeakHashMap

Méthode La description
clear() Supprime toutes les entrées de la carte
containsKey() Vérifie si la carte contient la clé spécifiée et renvoie une valeur booléenne
containsValue() Vérifie si la carte contient la valeur spécifiée et renvoie une valeur booléenne
size() Renvoie la taille de la carte
isEmpty() Vérifie si la carte est vide et renvoie une valeur booléenne

Pour en savoir plus, visitez Java WeakHashMap (documentation Java officielle).

Articles intéressants...