Java WeakHashMap

Neste tutorial, vamos aprender o Java WeakHashMap e suas operações com exemplos. Também vamos entender a diferença entre WeakHashMap e HashMap

A classe WeakHashMap fornecida pelo Java Collection Framework oferece funcionalidades de estrutura de dados de tabela de hashing.

Ele implementaMap interface。

Atenção：O hashmap de chave fraca pertence aWeakReferenceTipo.

Os objetos de tipo referência fraca podem ser coletados pelo garbage collector em Java, se a referência não estiver mais sendo usada no programa.

Primeiro vamos aprender a criar um mapeamento de hashing fraco. Em seguida, vamos entender a diferença entre ele e o hashmap.

Criar um WeakHashMap

Para criar uma tabela de hashing fraca,我们必须 primeiro importar o pacote java.util.WeakHashMap. Após a importação do pacote, podemos usar o seguinte método para criar uma tabela de hashing fraca em Java.

//Criar WeakHashMap, capacidade de8，fator de carga 0.6
WeakHashMap<Key,　Value>　numbers　=　new　WeakHashMap<>(8,　0.6);

No código acima, criamos um WeakHashMap chamado numbers.

Aqui,

• Chave - Usado para identificar de forma única cada elemento (valor) no mapeamento

• Value - Os elementos mapeados no mapeamento com a chave

Atenção new WeakHashMap<>(8,0.6)esta parte. Aqui, o primeiro parâmetro é capacity, o segundo parâmetro é loadFactor.

• capacity - A capacidade deste mapeamento é8Isso significa que pode armazenar8itens.

• loadFactor- O fator de carga deste mapeamento é 0.6Isso significa que sempre que nossa tabela de hashing estiver cheia60%，o item será movido para uma nova tabela de hashing, cujo tamanho é o dobro da tabela de hashing original.

Capacidade padrão e fator de carga

Pode criar um WeakHashMap sem definir sua capacidade e fator de carga. Por exemplo,

//com capacidade e fator de carga padrão
WeakHashMap<Key, Value> numbers1　= new WeakHashMap<>();

Padrão,

• A capacidade do mapa será 16

• O fator de carga será 0.75

Diferenças entre HashMap e WeakHashMap

Vamos ver a implementação de WeakHashMap no Java.

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar WeakHashMap com o nome 'numbers'
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String two = new String("Dois");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　String ",four" = new String("Four");
　　　　　　　　Integer ",fourValue" =　4;
　　　　　　　　//Inserir elemento
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　numbers.put(four, fourValue);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　　　　　//Referência nula
　　　　　　　　two = null;
　　　　　　　　//Executar a coleta de lixo
　　　　　　　　System.gc();
　　　　　　　　System.out.println("HashMap após a coleta de lixo fraca: ");　+　numbers);
　　　　}
}

Resultados de Saída

WeakHashMap: {Four=4, ",Two="2}
HashMap após a coleta de lixo fraca: {Four}

Como vimos, quando a chave 'two' do WeakHashMap é definida como null e a coleta de lixo é executada, a chave será excluída.

Isso é porque, diferentemente da tabela de hash, as chaves da WeakHashMap pertencemReferência fracaTipo. Isso significa que se a entrada do mapeamento não for mais usada, o coletor de lixo deletará a entrada. Isso é útil para economizar recursos.

Agora vamos ver a mesma implementação dentro de um hash map.

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar HashMap de números pares
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　String two = new String("Dois");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　String ",four" = new String("Four");
　　　　　　　　Integer ",fourValue" =　4;
　　　　　　　　//Inserir elemento
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　numbers.put(four, fourValue);
　　　　　　　　System.out.println("HashMap: "　+　numbers);
　　　　　　　　//Fazer a referência ser nula
　　　　　　　　two = null;
　　　　　　　　//Executar a coleta de lixo
　　　　　　　　System.gc();
　　　　　　　　System.out.println("HashMap após a coleta de lixo: ");　+　numbers);
　　　　}
}

Resultados de Saída

HashMap: {Four=4, ",Two="2}
HashMap após a coleta de lixo: {Four=4, ",Two="2}

Aqui, ao definir a chave da tabela de hash 'two' como null e executar a coleta de lixo, a chave não será excluída.

Isso é porque, diferentemente do WeakHashMap, as chaves do HashMap têmReferência forteTipo. Isso significa que, mesmo que a entrada do mapeamento não seja mais usada, a entrada não será excluída pelo coletor de lixo.

Atenção：HashMap e WeakHashMap têm todas as funções semelhantes, exceto que as chaves do WeakHashMap são referências fracas, enquanto as chaves do HashMap são referências fortes.

Criar WeakHashMap a partir de outros mapeamentos

Esta é a maneira como podemos criar uma tabela de hash fraca a partir de outros mapas.

import java.util.HashMap;
import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar um HashMap de números pares　
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　String two = new String("Dois");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　evenNumbers.put(two, ",twoValue");
　　　　　　　　System.out.println("HashMap: "　+　evenNumbers);
　　　　　　　　//　从其他哈希映射创建弱哈希映射　
　　　　　　　　WeakHashMap<String, ",Integer"> numbers = new WeakHashMap<>(evenNumbers);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　}
}

Resultados de Saída

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

WeakHashMap的方法

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

• put() - 将指定的键/

• putAll() -

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

Por exemplo,

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar WeakHashMap de números pares　
　　　　　　　　WeakHashMap<String, ",Integer"> evenNumbers = new WeakHashMap<>();
　　　　　　　　String two = new String("Dois");
　　　　　　　　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("Um");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　//　使用 ",putAll()",
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("WeakHashMap的数字: ",　+　numbers);
　　　　}
}

Resultados de Saída

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

1

• entrySet() - 返回一组所有键/

• keySet() -

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

Por exemplo,

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar WeakHashMap de números pares　
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String one = new String("Um");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　String two = new String("Dois");
　　　　　　　　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());
　　　　}
}

Resultados de Saída

WeakHashMap: {Two=2, One=1}
Chave/Mapeamento de valor: [Dois=2, One=1]
Chaves: [Dois, Um]
Valores: [1,　2]

2. Usando get() e getOrDefault()

• get()- Retorna o valor associado à chave especificada. Se a chave não for encontrada, retorna null.

• getOrDefault() - Retorna o valor associado à chave especificada. Se a chave não for encontrada, retorna o valor padrão especificado.

Por exemplo,

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

Resultados de Saída

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

Remover elementos do WeakHashMap

• remove(key) - Retorna e remove o item associado à chave especificada.

• remove(key, value) - Remove a entrada do mapeamento apenas quando a chave especificada mapeia para o valor especificado e retorna um valor booleano

Por exemplo,

import java.util.WeakHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar WeakHashMap de números pares　
　　　　　　　　WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
　　　　　　　　String one = new String("Um");
　　　　　　　　Integer oneValue =　1;
　　　　　　　　numbers.put(one, oneValue);
　　　　　　　　String two = new String("Dois");
　　　　　　　　Integer twoValue =　2;
　　　　　　　　numbers.put(two, twoValue);
　　　　　　　　System.out.println("WeakHashMap: ")　+　numbers);
　　　　　　　　//　usando remove() com1parâmetros
　　　　　　　　int value = numbers.remove("Dois");
　　　　　　　　System.out.println("Remover valor: ")　+　value);
　　　　　　　　//　usando remove() com2parâmetros
　　　　　　　　boolean result = numbers.remove("One",　3);
　　　　　　　　System.out.println("Item {One=",3} Foi removido? \　+　result);
　　　　　　　　System.out.println("WeakHashMap atualizada: ",　+　numbers);
　　　　}
}

Resultados de Saída

WeakHashMap: {Two=2, One=1}
Remover valor:　2
Item {One=3} Foi removido? Falso
WeakHashMap atualizada: {One=1}

Outros Métodos WeakHashMap