Java WeakHashMap

Neste tutorial, aprenderemos sobre Java WeakHashMap e suas operações com a ajuda de exemplos. Também aprenderemos sobre as diferenças entre WeakHashMap e HashMap

A WeakHashMapclasse do framework de coleções Java fornece o recurso da estrutura de dados da tabela hash …

Ele implementa a interface do Mapa.

Nota : As chaves do hashmap fraco são do tipo WeakReference .

O objeto de um tipo de referência fraca pode ser coletado como lixo em Java se a referência não for mais usada no programa.

Vamos aprender a criar um mapa hash fraco primeiro. Então, aprenderemos como ele difere de um hashmap.

Crie um WeakHashMap

Para criar um hashmap fraco, devemos importar o java.util.WeakHashMappacote primeiro. Depois de importar o pacote, aqui está como podemos criar hashmaps fracos em Java.

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

No código acima, criamos um hashmap fraco denominado números.

Aqui,

  • Chave - um identificador único usado para associar cada elemento (valor) em um mapa
  • Valor - elementos associados por chaves em um mapa

Observe a peça new WeakHashMap(8, 0.6). Aqui, o primeiro parâmetro é a capacidade e o segundo parâmetro é loadFactor .

  • capacidade - A capacidade deste mapa é 8. Ou seja, ele pode armazenar 8 entradas.
  • loadFactor - O fator de carga deste mapa é 0,6. Isso significa que sempre que nossa tabela hash é preenchida em 60%, as entradas são movidas para uma nova tabela hash com o dobro do tamanho da tabela original.

Capacidade padrão e fator de carga

É possível criar um hashmap fraco sem definir sua capacidade e fator de carga. Por exemplo,

 // WeakHashMap with default capacity and load factor WeakHashMap numbers1 = new WeakHashMap();

Por padrão,

  • a capacidade do mapa será de 16
  • o fator de carga será 0,75

Diferenças entre HashMap e WeakHashMap

Vamos ver a implementação de um hashmap fraco em Java.

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of numbers WeakHashMap 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); ) )

Resultado

 WeakHashMap: (Quatro = 4, Dois = 2) WeakHashMap após a coleta de lixo: (Quatro)

Como podemos ver, quando a chave dois de um hashmap fraco é definida nulle executa a coleta de lixo, a chave é removida.

É porque, ao contrário dos hashmaps, as chaves dos hashmaps fracos são do tipo de referência fraca . Isso significa que a entrada de um mapa é removida pelo coletor de lixo se a chave para essa entrada não for mais usada. Isso é útil para economizar recursos.

Agora vamos ver a mesma implementação em um hashmap.

 import java.util.HashMap; class Main ( public static void main(String() args) ( // Creating HashMap of even numbers HashMap 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); ) )

Resultado

 HashMap: (Quatro = 4, Dois = 2) HashMap após a coleta de lixo: (Quatro = 4, Dois = 2)

Aqui, quando a chave dois do hashmap é definida nulle executa a coleta de lixo, a chave não é removida.

Isso ocorre porque, ao contrário dos hashmaps fracos, as chaves dos hashmaps são do tipo de referência forte . Isso significa que a entrada de um mapa não é removida pelo coletor de lixo, embora a chave para essa entrada não seja mais usada.

Nota : Todas as funcionalidades de hashmaps e hashmaps fracos são semelhantes, exceto as chaves de um hashmap fraco são de referência fraca, enquanto as chaves de um hashmap são de referência forte.

Criação de WeakHashMap de outros mapas

Aqui está como podemos criar um hashmap fraco de outros mapas.

 import java.util.HashMap; import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating a hashmap of even numbers HashMap 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 numbers = new WeakHashMap(evenNumbers); System.out.println("WeakHashMap: " + numbers); ) )

Resultado

 HashMap: (Dois = 2) WeakHashMap: (Dois = 2)

Métodos de WeakHashMap

A WeakHashMapclasse fornece métodos que nos permitem realizar várias operações no mapa.

Inserir elementos no WeakHashMap

  • put() - insere o mapeamento de chave / valor especificado no mapa
  • putAll() - insere todas as entradas do mapa especificado neste mapa
  • putIfAbsent() - insere o mapeamento de chave / valor especificado no mapa se a chave especificada não estiver presente no mapa

Por exemplo,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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 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); ) )

Resultado

 WeakHashMap de números pares: (Quatro = 4, Dois = 2) WeakHashMap de números: (Dois = 2, Quatro = 4, Um = 1)

Acessar elementos WeakHashMap

1. Using entrySet(), keySet() and values()

  • entrySet() - returns a set of all the key/value mapping of the map
  • keySet() - returns a set of all the keys of the map
  • values() - returns a set of all the values of the map

For example,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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()); ) )

Output

 WeakHashMap: (Two=2, One=1) Key/Value mappings: (Two=2, One=1) Keys: (Two, One) Values: (1, 2)

2. Using get() and getOrDefault()

  • get() - Returns the value associated with the specified key. Returns null if the key is not found.
  • getOrDefault() - Returns the value associated with the specified key. Returns the specified default value if the key is not found.

For example,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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); ) )

Output

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

Remove WeakHashMap Elements

  • remove(key) - returns and removes the entry associated with the specified key from the map
  • remove(key, value) - removes the entry from the map only if the specified key mapped to the specified value and return a boolean value

For example,

 import java.util.WeakHashMap; class Main ( public static void main(String() args) ( // Creating WeakHashMap of even numbers WeakHashMap 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); ) )

Output

WeakHashMap: (Dois = 2, Um = 1) Valor removido: 2 A entrada (Um = 3) foi removida? WeakHashMap falso atualizado: (Um = 1)

Outros métodos de WeakHashMap

Método Descrição
clear() Remove todas as entradas do mapa
containsKey() Verifica se o mapa contém a chave especificada e retorna um valor booleano
containsValue() Verifica se o mapa contém o valor especificado e retorna um valor booleano
size() Retorna o tamanho do mapa
isEmpty() Verifica se o mapa está vazio e retorna um valor booleano

Para saber mais, visite Java WeakHashMap (documentação oficial do Java).

Artigos interessantes...