Java WeakHashMap

In deze zelfstudie leren we over Java WeakHashMap en de werking ervan met behulp van voorbeelden. We zullen ook leren over de verschillen tussen WeakHashMap en HashMap

De WeakHashMap klasse van het Java-verzamelingsraamwerk biedt de functie van de hash-tabelgegevensstructuur..

Het implementeert de kaartinterface.

Opmerking :Sleutels van de zwakke hashmap zijn van de WeakReference typ.

Het object van een zwak referentietype kan in Java worden verzameld als de referentie niet langer in het programma wordt gebruikt.

Laten we eerst leren om een zwakke hash-kaart te maken. Daarna zullen we leren hoe het verschilt van een hashmap.

Maak een WeakHashMap

Om een zwakke hashmap te maken, moeten we de java.util.WeakHashMap . importeren pakket eerst. Zodra we het pakket hebben geïmporteerd, kunnen we als volgt zwakke hashmaps maken in Java.

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

In de bovenstaande code hebben we een zwakke hashmap gemaakt met de naam getallen .

Hier,

Sleutel - een unieke identificatie die wordt gebruikt om elk element (waarde) in een kaart te associëren
Waarde - elementen geassocieerd met sleutels in een kaart

Let op het onderdeel new WeakHashMap<>(8, 0.6) . Hier is de eerste parameter capaciteit en de tweede parameter is loadFactor .

capaciteit - De capaciteit van deze kaart is 8. Dit betekent dat er 8 items kunnen worden opgeslagen.
loadFactor - De belastingsfactor van deze kaart is 0,6. Dit betekent dat wanneer onze hashtabel met 60% is gevuld, de items worden verplaatst naar een nieuwe hashtabel van het dubbele van de oorspronkelijke hashtabel.

Standaardcapaciteit en belastingsfactor

Het is mogelijk om een zwakke hashmap te maken zonder de capaciteit en belastingsfactor te definiëren. Bijvoorbeeld,

// WeakHashMap with default capacity and load factor
WeakHashMap<Key, Value> numbers1 = new WeakHashMap<>();

Standaard,

de capaciteit van de kaart is 16
de belastingsfactor zal 0,75 zijn

Verschillen tussen HashMap en WeakHashMap

Laten we eens kijken naar de implementatie van een zwakke hashmap in 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);
    }
}

Uitvoer

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

Zoals we kunnen zien, wanneer de sleutel twee van een zwakke hashmap is ingesteld op null en het ophalen van afval uitvoert, wordt de sleutel verwijderd.

Het is omdat, in tegenstelling tot hashmaps, sleutels van zwakke hashmaps van zwakke referentie zijn type. Dit betekent dat de invoer van een kaart door de vuilnisman wordt verwijderd als de sleutel tot die invoer niet meer wordt gebruikt. Dit is handig om bronnen te besparen.

Laten we nu dezelfde implementatie in een hashmap bekijken.

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

Uitvoer

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

Hier, wanneer de sleutel twee van de hashmap is ingesteld op null en het ophalen van afval uitvoert, wordt de sleutel niet verwijderd.

Dit komt omdat, in tegenstelling tot zwakke hashmaps, sleutels van hashmaps van sterke referentie zijn type. Dit betekent dat de invoer van een kaart niet door de vuilnisman wordt verwijderd, ook al wordt de sleutel tot die invoer niet meer gebruikt.

Opmerking :Alle functionaliteiten van hashmaps en zwakke hashmaps zijn vergelijkbaar, behalve dat sleutels van een zwakke hashmap een zwakke referentie zijn, terwijl sleutels van een hashmap een sterke referentie zijn.

WeakHashMap maken van andere kaarten

Hier is hoe we een zwakke hashmap van andere kaarten kunnen maken.

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

Uitvoer

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

Methoden van WeakHashMap

De WeakHashMap class biedt methoden waarmee we verschillende bewerkingen op de kaart kunnen uitvoeren.

Elementen invoegen in WeakHashMap

put() - voegt de opgegeven sleutel/waarde-toewijzing in op de kaart
putAll() - voegt alle vermeldingen van de opgegeven kaart in op deze kaart
putIfAbsent() - voegt de gespecificeerde sleutel/waarde-toewijzing toe aan de kaart als de gespecificeerde sleutel niet aanwezig is in de kaart

Bijvoorbeeld,

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

Uitvoer

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

Toegang tot WeakHashMap-elementen

1. entrySet(), keySet() en values() gebruiken

entrySet() - retourneert een set van alle sleutel/waarde-toewijzingen van de kaart
keySet() - geeft een set van alle sleutels van de kaart terug
values() - geeft een set van alle waarden van de kaart terug

Bijvoorbeeld,

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

Uitvoer

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

2. Get() en getOrDefault() gebruiken

get() - Retourneert de waarde die is gekoppeld aan de opgegeven sleutel. Retourneert null als de sleutel niet wordt gevonden.
getOrDefault() - Retourneert de waarde die is gekoppeld aan de opgegeven sleutel. Retourneert de opgegeven standaardwaarde als de sleutel niet wordt gevonden.

Bijvoorbeeld,

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

    }
}

Uitvoer

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

WeakHashMap-elementen verwijderen

remove(key) - retourneert en verwijdert de invoer die is gekoppeld aan de opgegeven sleutel van de kaart
remove(key, value) - verwijdert het item alleen van de kaart als de opgegeven sleutel is toegewezen aan de opgegeven waarde en retourneert een booleaanse waarde

Bijvoorbeeld,

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

Uitvoer

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

Andere methoden van WeakHashMap

Methode	Beschrijving
`clear()`	Verwijdert alle vermeldingen van de kaart
`containsKey()`	Controleert of de kaart de opgegeven sleutel bevat en retourneert een booleaanse waarde
`containsValue()`	Controleert of de kaart de opgegeven waarde bevat en retourneert een booleaanse waarde
`size()`	Retourneert de grootte van de kaart
`isEmpty()`	Controleert of de kaart leeg is en geeft een booleaanse waarde terug

Ga voor meer informatie naar Java WeakHashMap (officiële Java-documentatie).

Java LinkedHashMap Java EnumMap

Java