Clase WeakHashMap en Java

WeakHashMap es una implementación de la interfaz Map. WeakHashMap es casi lo mismo que HashMap excepto en el caso de WeakHashMap si el objeto se especifica como la clave no contiene ninguna referencia, es elegible para la recolección de elementos no utilizados aunque esté asociado con WeakHashMap. es decir, Garbage Collector domina sobre WeakHashMap.

WeakHashMap es la implementación basada en tablas Hash de la interfaz Map, con claves débiles. Una entrada en un WeakHashMap se eliminará automáticamente cuando su clave ya no se use normalmente. Más precisamente, la presencia de un mapeo para una clave dada no impedirá que el recolector de elementos no utilizados descarte la clave, es decir, que la haga finalizable, finalizada y luego reclamada. Cuando se ha descartado una clave, su entrada se elimina efectivamente del mapa, por lo que esta clase se comporta de forma un tanto diferente a otras implementaciones de mapas.

Algunas características importantes de una clase WeakHashMap son:

• Tanto los valores nulos como las claves nulas son compatibles con WeakHashMap.
• No está sincronizado.
• Esta clase está pensada principalmente para usarse con objetos clave cuyos métodos de igualdad prueban la identidad del objeto usando el operador ==.

Constructores en WeakHashMap

1. WeakHashMap(): este constructor se utiliza para crear un WeakHashMap vacío con la capacidad inicial predeterminada (16) y el factor de carga (0,75). 

2. WeakHashMap(int initialCapacity): este constructor se utiliza para crear un WeakHashMap vacío con la capacidad inicial dada y el factor de carga predeterminado (0,75). 

3. WeakHashMap(int initialCapacity, float loadFactor): este constructor se usa para crear un WeakHashMap vacío con la capacidad inicial dada y el factor de carga dado. 

4. WeakHashMap(Map m): este constructor se usa para crear un nuevo WeakHashMap con las mismas asignaciones que el mapa especificado.

Métodos en WeakHashMap

Ejemplo 1:

// Java Program to Illustrate WeakHashMap class
// Via close(), containsValue(), containsKey()
// and isEmpty() method
  
// Importing required classes
import java.util.Map;
import java.util.WeakHashMap;
  
// Main class
// WeakHashMapdemo
class GFG {
  
    // Main driver method
    public static void main(String[] arg)
    {
  
        // Creating an empty WeakHashMap
        // of Number and string type
        Map<Number, String> weak
            = new WeakHashMap<Number, String>();
  
        // Inserting custom elements
        // using put() method
        weak.put(1, "geeks");
        weak.put(2, "for");
        weak.put(3, "geeks");
  
        // Printing and alongside checking weak map
        System.out.println("our weak map: " + weak);
  
        // Checking if "for" exist
        if (weak.containsValue("for"))
            System.out.println("for exist");
  
        // Checking if 1 exist as a key in Map
        if (weak.containsKey(1))
            System.out.println("1 exist");
  
        // Removing all data
        // using clear() method
        weak.clear();
  
        // Checking whether the Map is empty or not
        // using isEmpty() method
        if (weak.isEmpty())
  
            // Display message for better readability
            System.out.println("empty map: " + weak);
    }
}

our weak map: {3=geeks, 2=for, 1=geeks}
for exist
1 exist
empty map: {}

 Ejemplo 2:

// Java Program to Illustrate WeakHashMap class
// Via entrySet(), keySet() and Values() Method
  
// Importing required classes
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
  
// Main class
// WeakHashMapdemo
class GFG {
  
    // Main driver method
    public static void main(String[] arg)
    {
  
        // Creating an empty WeakHashMap
        // of number and string type
        Map<Number, String> weak
            = new WeakHashMap<Number, String>();
  
        // Inserting elements
        // using put() method
        weak.put(1, "geeks");
        weak.put(2, "for");
        weak.put(3, "geeks");
  
        // Creating object of Set interface
        Set set1 = weak.entrySet();
  
        // Checking above Set
        System.out.println(set1);
  
        // Creating set for key
        Set keySet = weak.keySet();
  
        // Checking keySet
        System.out.println("key set: " + keySet);
  
        Collection value = weak.values();
  
        // Checking values of map and printing them
        System.out.println("values: " + value);
    }
}

[3=geeks, 2=for, 1=geeks]
key set: [3, 2, 1]
values: [geeks, for, geeks]

Ejemplo 3:

// Java code remove(), putAll()
// get() and size() method
  
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
  
class WeakHashMapdemo {
    public static void main(String[] arg)
    {
        Map<Number, String> weak
            = new WeakHashMap<Number, String>();
        weak.put(1, "geeks");
        weak.put(2, "for");
        weak.put(3, "geeks");
  
        Map<Number, String> weak1
            = new WeakHashMap<Number, String>();
        weak1.putAll(weak);
  
        // Getting value of key 2
        System.out.println(weak1.get(2));
  
        // Printing the size of map
        // using size() method
        System.out.println("Size of map is: "
                           + weak1.size());
  
        // Removing second element
        // using standard remove() method
        weak1.remove(2);
  
        // Printing the size after removing key and value
        // pair
        System.out.println("Size after removing: "
                           + weak1.size());
    }
}

for
Size of map is: 3
Size after removing: 2

Este artículo es una contribución de Abhishek Verma . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.