Java WeakHashMap

Carte de hachage faible Java

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

Le WeakHashMap classe du framework de collections Java fournit la fonctionnalité de la structure de données de la table de hachage..

Il implémente l'interface Map.

Remarque :Les clés du hashmap faible sont de la WeakReference saisir.

L'objet d'un type de référence faible peut être ramassé 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 importer le java.util.WeakHashMap paquet d'abord. Une fois que nous avons importé le package, voici comment nous pouvons créer des hashmaps faibles en Java.

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

Dans le code ci-dessus, nous avons créé un hashmap faible nommé numbers .

Ici,

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

Remarquez la partie 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 de 8. Cela signifie qu'elle peut stocker 8 entrées.
facteur de charge - 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 dont la taille est le double de la table de hachage d'origine.

Capacité et facteur de charge par défaut

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<Key, Value> 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<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);
    }
}

Sortie

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

Comme nous pouvons le voir, lorsque la clé deux d'un hashmap faible est défini sur null et effectuer une récupération de place, la clé est supprimée.

C'est parce que contrairement aux hashmaps, les clés des hashmaps faibles sont de référence faible taper. Cela signifie que l'entrée d'une carte est supprimée par le ramasse-miettes 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<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);
    }
}

Sortie

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

Ici, lorsque la clé deux du hashmap est défini sur null et effectuer une récupération de place, la clé n'est pas supprimée.

En effet, contrairement aux hashmaps faibles, les clés des hashmaps sont de référence forte taper. 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, tandis que les clés d'un hashmap sont de référence forte.

Créer WeakHashMap à partir d'autres cartes

Voici comment nous pouvons 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<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);
    }
}

Sortie

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

Méthodes de WeakHashMap

Le WeakHashMap 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<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);
    }
}

Sortie

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

Accéder aux éléments WeakHashMap

1. Utilisation de entrySet(), keySet() et values()

entrySet() - renvoie un ensemble de tous les mappages clé/valeur de la carte
keySet() - renvoie un ensemble de toutes les clés de la carte
values() - renvoie un ensemble de toutes les valeurs de la carte

Par exemple,

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

Sortie

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

2. Utilisation de get() et getOrDefault()

get() - Renvoie la valeur associée à la clé spécifiée. Renvoie null si la clé n'est pas trouvée.
getOrDefault() - Renvoie la valeur associée à la clé spécifiée. Renvoie la valeur par défaut spécifiée si la clé est introuvable.

Par exemple,

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

    }
}

Sortie

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

Supprimer les éléments WeakHashMap

remove(key) - renvoie et supprime l'entrée associée à la clé spécifiée de la carte
remove(key, value) - supprime l'entrée de la carte uniquement si la clé spécifiée correspond à la valeur spécifiée et renvoie une valeur booléenne

Par exemple,

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

Sortie

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

Autres méthodes de WeakHashMap

Méthode	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 officielle de Java).

Java LinkedHashMap Java EnumMap

Java