Java WeakHashMap

I den här handledningen lär vi oss om Java WeakHashMap och dess verksamhet med hjälp av exempel. Vi kommer också att lära oss om skillnaderna mellan WeakHashMap och HashMap

Den WeakHashMapklass av samlingar ramen för Java ger funktionen hos hashtabellen datastrukturen …

Det implementerar Map-gränssnittet.

Obs : Tangenterna för den svaga hashmap är av typen WeakReference .

Föremålet för en svag referens typ kan samlas i Java om referensen inte längre används i programmet.

Låt oss först lära oss att skapa en svag hash-karta. Sedan lär vi oss hur det skiljer sig från en hashmap.

Skapa en WeakHashMap

För att skapa en svag hashmap måste vi först importera java.util.WeakHashMappaketet. När vi väl har importerat paketet, här är hur vi kan skapa svaga hashmaps i Java.

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

I koden ovan har vi skapat en svag hashmap med namnen.

Här,

  • Nyckel - en unik identifierare som används för att associera varje element (värde) på en karta
  • Värde - element som är associerade med nycklar på en karta

Lägg märke till delen new WeakHashMap(8, 0.6). Här är den första parametern kapacitet och den andra parametern är loadFactor .

  • kapacitet - Kapaciteten på denna karta är 8. Det betyder att den kan lagra 8 poster.
  • loadFactor - Lastfaktorn för denna karta är 0,6. Det betyder att när vår hashtabell fylls med 60% flyttas posterna till en ny hashtabell med dubbelt så stor som den ursprungliga hashtabellen.

Standardkapacitet och lastfaktor

Det är möjligt att skapa en svag hashmap utan att definiera dess kapacitet och belastningsfaktor. Till exempel,

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

Som standard,

  • kartans kapacitet blir 16
  • belastningsfaktorn blir 0,75

Skillnader mellan HashMap och WeakHashMap

Låt oss se implementeringen av en svag hashmap i 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); ) )

Produktion

 WeakHashMap: (Fyra = 4, Två = 2) WeakHashMap efter sopuppsamling: (Fyra)

Som vi kan se, när nyckel två i en svag hashmap är inställd på nulloch utför sopuppsamling, tas nyckeln bort.

Det beror på att till skillnad från hashmaps är nycklarna till svaga hashmaps av svag referens . Detta innebär att inmatningen av en karta tas bort av sopuppsamlaren om nyckeln till den inmatningen inte längre används. Detta är användbart för att spara resurser.

Låt oss nu se samma implementering i en 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); ) )

Produktion

 HashMap: (Fyra = 4, Två = 2) HashMap efter sopuppsamling: (Fyra = 4, Två = 2)

Här, när nyckel två i hashmap är inställd på nulloch utför sopuppsamling, tas nyckeln inte bort.

Detta beror på att till skillnad från svaga hashmaps är nycklarna till hashmaps av stark referens . Detta innebär att inmatningen av en karta inte tas bort av sopuppsamlaren trots att nyckeln till den inmatningen inte längre används.

Obs! Alla funktioner för hashmaps och svaga hashmaps är likartade utom knapparna för en svag hashmap är av svag referens, medan nycklarna till en hashmap har en stark referens.

Skapa WeakHashMap från andra kartor

Så här kan vi skapa en svag hashmap från andra kartor.

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

Produktion

 HashMap: (Two = 2) WeakHashMap: (Two = 2)

Metoder för WeakHashMap

I WeakHashMapklassen innehåller metoder som tillåter oss att utföra olika operationer på kartan.

Infoga element till WeakHashMap

  • put() - infogar den angivna nyckel- / värdekartläggningen på kartan
  • putAll() - infogar alla poster från specificerad karta till denna karta
  • putIfAbsent() - infogar den angivna nyckel- / värdekartläggningen på kartan om den angivna nyckeln inte finns på kartan

Till exempel,

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

Produktion

 WeakHashMap av jämna siffror: (Fyra = 4, Två = 2) WeakHashMap av siffror: (Två = 2, Fyra = 4, En = 1)

Åtkomst till WeakHashMap-element

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: (Två = 2, En = 1) Borttaget värde: 2 Tar posten (En = 3) bort? Felaktigt uppdaterad WeakHashMap: (One = 1)

Andra metoder för WeakHashMap

Metod Beskrivning
clear() Tar bort alla poster från kartan
containsKey() Kontrollerar om kartan innehåller den angivna nyckeln och returnerar ett booleskt värde
containsValue() Kontrollerar om kartan innehåller det angivna värdet och returnerar ett booleskt värde
size() Returnerar storleken på kartan
isEmpty() Kontrollerar om kartan är tom och returnerar ett booleskt värde

För mer information, besök Java WeakHashMap (officiell Java-dokumentation).

Intressanta artiklar...