Java WeakHashMap

Mapa de hash débil de Java

En este tutorial, aprenderemos sobre Java WeakHashMap y sus operaciones con la ayuda de ejemplos. También aprenderemos sobre las diferencias entre WeakHashMap y HashMap

El WeakHashMap La clase del marco de colecciones de Java proporciona la característica de la estructura de datos de la tabla hash.

Implementa la interfaz del Mapa.

Nota :Las claves del hashmap débil son de WeakReference tipo.

El objeto de un tipo de referencia débil se puede recolectar basura en Java si la referencia ya no se usa en el programa.

Aprendamos primero a crear un mapa hash débil. Luego, aprenderemos en qué se diferencia de un hashmap.

---

Crear un WeakHashMap

Para crear un hashmap débil, debemos importar el java.util.WeakHashMap paquete primero. Una vez que importamos el paquete, así es como podemos crear hashmaps débiles en Java.

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

En el código anterior, hemos creado un hashmap débil llamado numbers .

Aquí,

• Clave - un identificador único utilizado para asociar cada elemento (valor) en un mapa
• Valor - elementos asociados por claves en un mapa

Observe la parte new WeakHashMap<>(8, 0.6) . Aquí, el primer parámetro es capacidad y el segundo parámetro es loadFactor .

• capacidad - La capacidad de este mapa es 8. Es decir, puede almacenar 8 entradas.
• factor de carga - El factor de carga de este mapa es 0,6. Esto significa que cada vez que nuestra tabla hash se llena en un 60 %, las entradas se mueven a una nueva tabla hash del doble del tamaño de la tabla hash original.

Capacidad predeterminada y factor de carga

Es posible crear un hashmap débil sin definir su capacidad y factor de carga. Por ejemplo,

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

Por defecto,

• la capacidad del mapa será de 16
• el factor de carga será 0,75

---

Diferencias entre HashMap y WeakHashMap

Veamos la implementación de un hashmap débil en 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);
    }
}

Salida

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

Como podemos ver, cuando la tecla dos de un hashmap débil se establece en null y realiza la recolección de basura, la clave se elimina.

Se debe a que, a diferencia de los hashmaps, las claves de los hashmaps débiles son de referencia débil. escribe. Esto significa que el recolector de basura elimina la entrada de un mapa si la clave de esa entrada ya no se usa. Esto es útil para ahorrar recursos.

Ahora veamos la misma implementación en un hashmap.

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

Salida

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

Aquí, cuando la tecla dos del hashmap está establecido en null y realizar la recolección de basura, la clave no se elimina.

Esto se debe a que, a diferencia de los mapas hash débiles, las claves de los mapas hash son de fuerte referencia. escribe. Esto significa que el recolector de basura no elimina la entrada de un mapa aunque la clave de esa entrada ya no se use.

Nota :Todas las funcionalidades de hashmaps y hashmaps débiles son similares excepto que las claves de un hashmap débil son de referencia débil, mientras que las claves de un hashmap son de referencia fuerte.

---

Creación de WeakHashMap a partir de otros mapas

Así es como podemos crear un mapa hash débil a partir de otros mapas.

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

Salida

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

---

Métodos de WeakHashMap

El WeakHashMap La clase proporciona métodos que nos permiten realizar varias operaciones en el mapa.

---

Insertar elementos en WeakHashMap

• put() - inserta la asignación clave/valor especificada en el mapa
• putAll() - inserta todas las entradas del mapa especificado a este mapa
• putIfAbsent() - inserta la asignación clave/valor especificada en el mapa si la clave especificada no está presente en el mapa

Por ejemplo,

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

Salida

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

---

Acceso a elementos de WeakHashMap

1. Uso de entrySet(), keySet() y valores()

• entrySet() - devuelve un conjunto de todas las asignaciones de clave/valor del mapa
• keySet() - devuelve un conjunto de todas las claves del mapa
• values() - devuelve un conjunto de todos los valores del mapa

Por ejemplo,

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

Salida

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

2. Usando get() y getOrDefault()

• get() - Devuelve el valor asociado a la clave especificada. Devuelve null si no se encuentra la clave.
• getOrDefault() - Devuelve el valor asociado a la clave especificada. Devuelve el valor predeterminado especificado si no se encuentra la clave.

Por ejemplo,

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

    }
}

Salida

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

---

Eliminar elementos de WeakHashMap

• remove(key) - devuelve y elimina la entrada asociada con la clave especificada del mapa
• remove(key, value) - elimina la entrada del mapa solo si la clave especificada se asigna al valor especificado y devuelve un valor booleano

Por ejemplo,

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

Salida

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

---

Otros métodos de WeakHashMap

Método	Descripción
clear()	Elimina todas las entradas del mapa
containsKey()	Comprueba si el mapa contiene la clave especificada y devuelve un valor booleano
containsValue()	Comprueba si el mapa contiene el valor especificado y devuelve un valor booleano
size()	Devuelve el tamaño del mapa
isEmpty()	Comprueba si el mapa está vacío y devuelve un valor booleano

---

Para obtener más información, visite Java WeakHashMap (documentación oficial de Java).