Java WeakHashMap

En este tutorial, aprenderemos Java WeakHashMap y sus operaciones a través de ejemplos. También entenderemos la diferencia entre WeakHashMap y HashMap.

La clase WeakHashMap proporcionada por el Java Collection Framework ofrece las funciones de estructura de tabla de hash.

ImplementaMap interfaz.

注意: el hashmap de clave débil pertenece aWeakReferenceTipo.

Los objetos de tipo referencia débil pueden ser reciclados por el recolector de basura en Java si la referencia ya no se utiliza en el programa.

Primero, aprendamos a crear un mapeo de tabla de hash débil. Luego, entenderemos la diferencia entre él y hashmap.

Crear una WeakHashMap

Para crear una tabla de hash débil, primero debemos importar el paquete java.util.WeakHashMap. Después de importar el paquete, podemos crear una tabla de hash débil en Java utilizando el siguiente método.

//Crear WeakHashMap, capacidad de8，factor de carga 0.6
WeakHashMap<Key,　Value>　numbers　=　new　WeakHashMap<>(8,　0.6);

En el código anterior, creamos una WeakHashMap llamada numbers.

Aquí,

• Clave - Se utiliza como identificador único para asociar cada elemento (valor) en el mapeo

• Value - Los elementos asociados con la clave en el mapeo

Nota: new WeakHashMap<>(8,0.6)esta parte. Aquí, el primer parámetro es capacity, el segundo parámetro es loadFactor.

• capacity - La capacidad de este mapeo es8Esto significa que puede almacenar8entradas.

• loadFactor- El factor de carga de este mapeo es 0.6Esto significa que siempre que nuestra tabla de hash esté llena60％，las entradas se transferirán a una nueva tabla de hash, cuyo tamaño es el doble de la tabla de hash original.

Capacidad y factor de carga predeterminados

Se puede crear una WeakHashMap sin definir su capacidad y factor de carga. Por ejemplo,

//具有默认容量和负载因子的WeakHashMap
WeakHashMap<Key, Value> numbers1　= new WeakHashMap<>();

默认，

• map的容量将为 16

• 负载因子将为0.75

HashMap和WeakHashMap之间的区别

让我们看看Java中弱哈希表的实现。

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　创建名称为numbers的WeakHashMap
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String two = new String("Dos");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　String four = new String("Four");
　　　　　　　　Integer fourValue =　4;
　　　　　　　　//插入元素
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　numbers.put(four, fourValue);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　　　　　//null引用
　　　　　　　　two = null;
　　　　　　　　//执行垃圾回收
　　　　　　　　System.gc();
　　　　　　　　System.out.println("Weak垃圾回收后的HashMap : " + "")　+　numbers);
　　　　}
}

Resultado de salida

WeakHashMap: {Four=4, "Two="2}
Weak垃圾回收后的HashMap : {Four}

如我们所见，当two弱哈希图的键设置为null并执行垃圾回收时，该键将被删除。

这是因为与散列表不同，弱散列表的键属于弱引用类型。这意味着如果不再使用映射条目，则垃圾收集器将删除该条目。这对于节省资源很有用。

现在让我们在哈希表中查看相同的实现。

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建偶数HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　String two = new String("Dos");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　String four = new String("Four");
　　　　　　　　Integer fourValue =　4;
　　　　　　　　//插入元素
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　numbers.put(four, fourValue);
　　　　　　　　System.out.println("HashMap: " + "")　+　numbers);
　　　　　　　　//使引用为空
　　　　　　　　two = null;
　　　　　　　　//执行垃圾回收
　　　　　　　　System.gc();
　　　　　　　　System.out.println("垃圾回收后的HashMap : " + "")　+　numbers);
　　　　}
}

Resultado de salida

HashMap: {Four=4, "Two="2}
垃圾回收后的HashMap : {Four=4, "Two="2}

在此，将哈希表的键two设置为null并执行垃圾回收时，不会删除该键。

这是因为与WeakHashMap不同，HashMap的键具有强引用类型。这意味着即使映射条目的键不再被使用，该条目也不会被垃圾回收器删除。

注意：HashMap和WeakHashMap的所有功能都是相似的，除了WeakHashMap的键是弱引用，而HashMap的键是强引用。

从其他映射创建WeakHashMap

这是我们可以从其他map创建弱哈希表的方法。

import java.util.HashMap;
import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　创建偶数的哈希表　
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　String two = new String("Dos");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　evenNumbers.put(two, twoValue);
　　　　　　　　System.out.println("HashMap: " + "")　+　evenNumbers);
　　　　　　　　//　从其他哈希映射创建弱哈希映射　
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>(evenNumbers);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　}
}

Resultado de salida

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

WeakHashMap 的方法

WeakHashMap 类提供了允许我们对映射执行各种操作的方法。

将元素插入 WeakHashMap

• put() - 将指定的键/值映射插入到映射中

• putAll() - 将指定映射中的所有条目插入到此映射中

• putIfAbsent() - 如果 map 中不存在指定的键，则将指定的键/值映射插入到 map 中

por ejemplo,

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Crear WeakHashMap de números pares　
　　　　　　　　WeakHashMap<String, Integer> evenNumbers = new WeakHashMap<>();
　　　　　　　　String two = new String("Dos");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　//　使用 put()
　　　　　　　　evenNumbers.put(two, twoValue);
　　　　　　　　String four = new String("Four");
　　　　　　　　Integer fourValue =　4;
　　　　　　　　//　使用 putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent(four, fourValue);
　　　　　　　　System.out.println("偶数的 WeakHashMap: " );　+　evenNumbers);
　　　　　　　　//创建名为 numbers 的 WeakHashMap
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String one = new String("Uno");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　//　使用 putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("WeakHashMap 的数字: " );　+　numbers);
　　　　}
}

Resultado de salida

偶数的 WeakHashMap: " {Four="4, "Two="2}
WeakHashMap 的数字: " {Two="2, "Four="4, One=,1}

访问 WeakHashMap 元素

1.使用 entrySet()，keySet() y values()

• entrySet() - 返回一组所有键/值映射的集合

• keySet() - 返回 map 所有键的集合

• values() - 返回 map 所有值的集合

por ejemplo,

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Crear WeakHashMap de números pares　
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String one = new String("Uno");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　String two = new String("Dos");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　　　　　//　使用 entrySet()
　　　　　　　　System.out.println("Key/Value 映射: "　+　numbers.entrySet());
　　　　　　　　//　使用 keySet()
　　　　　　　　System.out.println("Keys: " );　+　numbers.keySet());
　　　　　　　　//　Usando values()}
　　　　　　　　System.out.println("Valores: ")　+　numbers.values());
　　　　}
}

Resultado de salida

WeakHashMap: {Two=,2, One=,1}
Clave/Mapeo de valores: [Dos=2, One=,1]
Claves: [Dos, Uno]
Valores: [1,　2]

2.Usando get() y getOrDefault()

• get()- Devuelve el valor asociado con la clave especificada. Si no se encuentra la clave, devuelve null.

• getOrDefault() - Devuelve el valor asociado con la clave especificada. Si no se encuentra la clave, devuelve el valor de predeterminación especificado.

por ejemplo,

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Crear WeakHashMap de números pares　
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String one = new String("Uno");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　String two = new String("Dos");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　　　　　//　Usando get()
　　　　　　　　int value1　= numbers.get("Dos");
　　　　　　　　System.out.println("Usando el método get(): ")　+　value1);
　　　　　　　　//　Usando getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Cuatro",　4);
　　　　　　　　System.out.println("Usando el método getOrDefault(): ")　+　value2);
　　　　}
}

Resultado de salida

WeakHashMap: {Two=,2, One=,1}
Usando el método get():　2
Usando el método getOrDefault():　4

Eliminar elementos de WeakHashMap

• remove(key) - Devuelve y elimina el elemento asociado con la clave especificada.

• remove(key, value) - Elimina la entrada del mapa solo si la clave especificada está mapeada al valor especificado y devuelve un valor booleano

por ejemplo,

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Crear WeakHashMap de números pares　
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String one = new String("Uno");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　String two = new String("Dos");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　　　　　//　usando remove() y con1parámetros
　　　　　　　　int value = numbers.remove("Dos");
　　　　　　　　System.out.println("Eliminar valor: ")　+　value);
　　　　　　　　//　usando remove() y con2parámetros
　　　　　　　　boolean result = numbers.remove("One",　3);
　　　　　　　　System.out.println("Entrada {One=",3¿Ha sido eliminado? ",　+　result);
　　　　　　　　System.out.println("WeakHashMap actualizada: ",　+　numbers);
　　　　}
}

Resultado de salida

WeakHashMap: {Two=,2, One=,1}
Eliminar valor:　2
Entrada {One=,3} ¿Ha sido eliminado? Falso
WeakHashMap actualizada: {One=,1}

Otros métodos de WeakHashMap