Programa Java para implementar la API WeakHashMap

Posted on by Rudeus Greyrat

La clase WeakHashMap es parte de Java Collections Framework , implementando la interfaz Map y extendiendo la clase AbstractMap . La interfaz Map nos ayuda a asignar claves a valores, mientras que la clase AbstractMap facilita la implementación de la interfaz Map. 

Cada clave en un mapa debe ser única y puede unirse con un máximo de un valor. Tenga en cuenta que un mapa en sí mismo no puede ser una clave. El orden de los pares clave-valor no está garantizado en un WeakHashMap. Lo que hace que WeakHashMap sea diferente de un HashMap normal es que un WeakHashMap usa claves débiles.

Referencia fuerte: Una referencia fuerte es el tipo de referencia que se usa generalmente. El recolector de basura no reclama objetos que tengan una referencia fuerte.

Ejemplo:

Geek strongRef=new Geek();

Referencia débil: si un objeto no tiene una referencia fuerte o suave , se dice que el objeto tiene una referencia débil.

Ejemplo:

new Geek();

También se puede generar una referencia débil explícita usando la clase WeakReference

Ejemplo:

WeakReference<Geek> weakRef=new WeakReference(new Geek());

// Now use the get() method to obtain the object
// weakRef.get()

La presencia de claves débiles significa que el recolector de basura eliminará las claves una vez que ya no estén en uso. Por otro lado, los valores están en manos de referencias Fuertes. Entonces, los objetos de valor no deben referirse directamente a su clave más; esto evitará que se reclame la clave. WeakHashMap admite claves nulas y valores.

Factor de carga: el porcentaje de ocupación después del cual se duplica la capacidad de WeakHashMap. Por ejemplo, si la capacidad inicial es 16 y el factor de carga es 0,75 (75 %), es decir, 12, entonces, al agregar el elemento 13, el tamaño de WeakHashMap se duplica.

Constructores: la clase WeakHashMap proporciona 4 constructores:

1.WeakHashMap(): Esto generará un objeto WeakHashMap con una capacidad inicial de 16 y un factor de carga de 0,75

Sintaxis:

WeakHashMap<K,V> wHM=new WeakHashMap<K,V>();

2.WeakHashMap(int InitialCapacity): esto generará un objeto WeakHashMap con la capacidad inicial deseada y un factor de carga de 0,75

Sintaxis: 

WeakHashMap<K,V> wHM=new WeakHashMap<K,V>(20);

// This will generate a WeakHashMap 
// object with an initial capacity of 20

3.WeakHashMap(int InitialCapacity, float LoadFactor): esto generará un objeto WeakHashMap con la capacidad inicial deseada y el factor de carga.

Sintaxis:

WeakHashMap<K,V> wHM=new WeakHashMap<K,V>(20,0.9);

// This will generate a WeakHashMap object with an
// initial capacity of 20 and load factor of 90%

4.WeakHashMap (mapa de mapa): esto generará un objeto WeakHashMap y copiará todos los pares clave-valor del mapa especificado en el proceso.

Sintaxis:

WeakHashMap<K,V> wHM=new WeakHashMap<K,V>( oldMap);

// This will generate a WeakHashMap object and
//  will copy all the mappings of oldMap

Operaciones en WeakHashMap

Las operaciones de WeakHashMap se pueden clasificar como destructivas o no destructivas. Los métodos destructivos modifican el mapa sobre el que operan. 

Operaciones destructivas

1. Adición o Actualización

Cuando se inserta una clave en WeakHashMap, el siguiente proceso ocurre internamente:

  • Se genera un código hash único para esa clave en particular
  • Este código hash se utiliza para generar un valor de índice
  • El par clave-valor se almacena en ese índice particular en la tabla hash

A) T put público (clave K, valor T): inserta el par clave-valor dado en el WeakHashMap. Si la clave ya existe, el valor se actualiza. Este método devuelve el valor anterior de la clave. Si la clave se inserta por primera vez o el valor anterior es nulo, se devuelve nulo

B) putAll public void (mapa m): inserta todo el mapeo del mapa en el mapa actual. Si alguna clave es común, el valor se actualiza. Si el mapa m especificado es nulo, se lanza una NullPointerException.

2. Eliminación

A) public void clear(): elimina todas las asignaciones del mapa

B) public T remove(Object key): Elimina el mapeo asociado con el obj clave del mapa dado que existe. Este método devolverá el valor asociado con la clave que se está eliminando. Se devolverá un valor nulo si no existe dicha clave o si el valor en sí es nulo.

Operaciones no destructivas

Los métodos no destructivos no cambian el mapa en el que operan. Los métodos no destructivos son los siguientes:

1. containsKey: devuelve verdadero si el mapa contiene la clave especificada; de lo contrario, devuelve falso.

public boolean containsKey(Object Key)

2. containsValue: devuelve verdadero si el mapa contiene una clave con el valor especificado; de lo contrario, devuelve falso.

public boolean containsValue(Object Value)

3. get: Devuelve el valor adjunto con la clave especificada. null se devuelve si la clave no existe o si el valor en sí es nulo. 

public T get(Object Key)

4. tamaño: Devuelve el número de pares clave-valor presentes en el mapa en el instante en que se llama al método.

public int size()

5. isEmpty: devuelve verdadero si no hay pares clave-valor presentes en el mapa en el instante en que se llama al método; de lo contrario, devuelve falso.

public boolean isEmpty()

6. conjunto de entrada: un par clave-valor también se conoce como entrada de mapa. La interfaz Map.Entry nos permite trabajar con entradas de mapa. El método entrySet devolverá un conjunto de todas las entradas del mapa actual.

public Set<Map.Entry<K,V>> entrySet()

7. keySet: Devuelve un conjunto que contiene todas las claves presentes en el mapa. Los cambios realizados en el mapa se reflejan en este conjunto. Realizar operaciones en el mapa y atravesar el conjunto al mismo tiempo puede resultar en un comportamiento indefinido.

public Set<k> keySet()

8. valores: Devuelve una vista de colección de todos los valores presentes en el mapa. Los cambios realizados en el mapa se reflejan en esta colección. Realizar operaciones en el mapa y recorrer la colección al mismo tiempo puede dar como resultado un comportamiento indefinido.

public Collection<V> values()

Implementando WeakHashMap

El siguiente programa contiene la clase WHI, que implementa la API WeakHashMap. Esta implementación luego se usa aquí para asignar calificaciones a puntajes.

Java

// Java Program to implement WeakHashMap
 
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
 
// The class WHI will implement WeakHashMap
class WHI<K, V> {
 
    // Make a private WeakHashMap reference
    // variable
 
    private WeakHashMap<K, V> obj;
 
    // Constructors
 
    // Create WeakHashMap with capacity 16
    // and 0.75 load-factor
    public WHI() { obj = new WeakHashMap<K, V>(); }
 
    // Create WeakHashMap with desired capacity
    // and 0.75 load-factor
    public WHI(int initialCapacity)
    {
        obj = new WeakHashMap<K, V>(initialCapacity);
    }
 
    // Create WeakHashMap with desired capacity
    // and desired load-factor
    public WHI(int initialCapacity, float loadFactor)
    {
        obj = new WeakHashMap<K, V>(initialCapacity,
                                    loadFactor);
    }
 
    // Destructive-Methods
 
    // Place the key-value pair in the
    // WeakHashMap
 
    public V put(K key, V value)
    {
        return obj.put(key, value);
    }
 
    // Copy all the key-value pairs
    // from a map
    public void putAll(Map<K, V> map) { obj.putAll(map); }
 
    // Remove all the key-value pairs
    public void clear() { obj.clear(); }
 
    // Remove a particular key
    public V remove(Object key) { return obj.remove(key); }
 
    // Non-Destructive methods
 
    // Check if the map contains
    // a specific key
    public boolean containsKey(Object key)
    {
        return obj.containsKey(key);
    }
 
    // Check if the map contains a key
    // with specific value
    public boolean containsValue(Object value)
    {
        return obj.containsValue(value);
    }
 
    // get the value for a specific
    // key
    public V get(Object key) { return obj.get(key); }
 
    // get size of the map
    public int size() { return obj.size(); }
 
    // Check if the map is empty
    public boolean isEmpty() { return obj.isEmpty(); }
 
    // get a set of Map entries
    public Set<Map.Entry<K, V> > entrySet()
    {
        return obj.entrySet();
    }
 
    // get a set of keys
    public Set<K> keySet() { return obj.keySet(); }
 
    // get a Collection of values
    public Collection<V> values() { return obj.values(); }
}
 
public class Main {
 
    public static void main(String args[])
    {
 
        // Create an object of WHI class
        // key will be of type String
        // value will be of type Integer
        WHI<String, Integer> obj1
            = new WHI<String, Integer>();
 
        System.out.println(
            "The grades and cut off are as follows: ");
 
        // insert key-value pairs in the WeakHashMap object
 
        obj1.put("A+", 90);
        obj1.put("A", 80);
        obj1.put("B", 70);
        obj1.put("C", 60);
 
        // Traverse the set containing map entries
        // entrySet() is used to obtain the set
        for (Map.Entry<String, Integer> ivar :
             obj1.entrySet()) {
            System.out.println(ivar.getKey() + " "
                               + ivar.getValue());
        }
 
        // get value associated with key "B"
        System.out.println("The cut-off for B grade is "
                           + obj1.get("B"));
    }
}
Producción

The grades and cut off are as follows: 
A+ 90
C 60
B 70
A 80
The cut-off for B grade is 70

Nota: Es posible que las calificaciones y el corte se impriman de manera desordenada. Esto se debe a que el orden no está garantizado en un WeakHashMap.

Publicación traducida automáticamente

Artículo escrito por sanatr y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *