Java WeakHashMap

În acest tutorial, vom afla despre Java WeakHashMap și operațiunile sale cu ajutorul unor exemple. De asemenea, vom afla despre diferențele dintre WeakHashMap și HashMap

WeakHashMapClasa cadrului colecțiilor Java oferă caracteristica a structurii de date tabel hash …

Implementează interfața Map.

Notă : Tastele hashmapului slab sunt de tipul WeakReference .

Obiectul unui tip de referință slab poate fi gunoiul colectat în Java dacă referința nu mai este utilizată în program.

Să învățăm mai întâi să creăm o hartă hash slabă. Apoi, vom afla cum diferă de un hashmap.

Creați un WeakHashMap

Pentru a crea un hashmap slab, trebuie mai java.util.WeakHashMapîntâi să importăm pachetul. Odată ce am importat pachetul, iată cum putem crea hashmaps slabe în Java.

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

În codul de mai sus, am creat un hashmap slab numit numere.

Aici,

  • Cheie - un identificator unic utilizat pentru a asocia fiecare element (valoare) pe o hartă
  • Valoare - elemente asociate tastelor dintr-o hartă

Observați partea new WeakHashMap(8, 0.6). Aici, primul parametru este capacitatea, iar al doilea parametru este loadFactor .

  • capacitate - Capacitatea acestei hărți este 8. Adică, poate stoca 8 intrări.
  • loadFactor - Factorul de încărcare al acestei hărți este de 0,6. Acest lucru înseamnă că, de fiecare dată când tabelul nostru de hash este umplut cu 60%, intrările sunt mutate într-un nou tabel de hash de două ori mai mare decât tabelul de hash original.

Capacitatea implicită și factorul de încărcare

Este posibil să creați un hashmap slab fără a defini capacitatea și factorul de încărcare al acestuia. De exemplu,

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

În mod implicit,

  • capacitatea hărții va fi de 16
  • factorul de încărcare va fi 0,75

Diferențele dintre HashMap și WeakHashMap

Să vedem implementarea unui hashmap slab în 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); ) )

Ieșire

 WeakHashMap: (Patru = 4, Două = 2) WeakHashMap după colectarea gunoiului: (Patru)

După cum putem vedea, atunci când cheia două a unui hashmap slab este setată la nullși efectuează colectarea gunoiului, cheia este eliminată.

Deoarece, spre deosebire de hashmaps, tastele hashmaps slabe sunt de tip slab de referință . Aceasta înseamnă că intrarea unei hărți este eliminată de colectorul de gunoi dacă nu mai este utilizată cheia respectivei intrări. Acest lucru este util pentru a economisi resurse.

Acum să vedem aceeași implementare într-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); ) )

Ieșire

 HashMap: (Patru = 4, Două = 2) HashMap după colectarea gunoiului: (Patru = 4, Două = 2)

Aici, când cheia două a hashmap-ului este setată la nullși efectuează colectarea gunoiului, cheia nu este eliminată.

Acest lucru se datorează faptului că, spre deosebire de hashmaps slabe, cheile hashmaps sunt de tip puternic de referință . Aceasta înseamnă că intrarea unei hărți nu este eliminată de colectorul de gunoi, chiar dacă cheia pentru intrarea respectivă nu mai este utilizată.

Note: All functionalities of hashmaps and weak hashmaps are similar except keys of a weak hashmap are of weak reference, whereas keys of a hashmap are of strong reference.

Creating WeakHashMap from Other Maps

Here is how we can create a weak hashmap from other maps.

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

Output

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

Methods of WeakHashMap

The WeakHashMap class provides methods that allow us to perform various operations on the map.

Insert Elements to WeakHashMap

  • put() - inserts the specified key/value mapping to the map
  • putAll() - inserts all the entries from specified map to this map
  • putIfAbsent() - inserts the specified key/value mapping to the map if the specified key is not present in the map

For example,

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

Output

 WeakHashMap of even numbers: (Four=4, Two=2) WeakHashMap of numbers: (Two=2, Four=4, One=1)

Access WeakHashMap Elements

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: (Două = 2, Unu = 1) Valoare eliminată: 2 Este eliminată intrarea (Unu = 3)? Actualizare falsă WeakHashMap: (Unu = 1)

Alte metode ale WeakHashMap

Metodă Descriere
clear() Elimină toate intrările de pe hartă
containsKey() Verifică dacă harta conține cheia specificată și returnează o valoare booleană
containsValue() Verifică dacă harta conține valoarea specificată și returnează o valoare booleană
size() Returnează dimensiunea hărții
isEmpty() Verifică dacă harta este goală și returnează o valoare booleană

Pentru a afla mai multe, vizitați Java WeakHashMap (documentație oficială Java).

Articole interesante...