Java WeakHashMap

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

O WeakHashMap A classe da estrutura de coleções Java fornece o recurso da estrutura de dados da tabela de hash.

Ele implementa a interface Map.

Observação :As chaves do hashmap fraco são do WeakReference modelo.

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

Vamos aprender a criar um mapa de hash fraco primeiro. Em seguida, aprenderemos como ele difere de um hashmap.

Criar um WeakHashMap

Para criar um hashmap fraco, devemos importar o java.util.WeakHashMap pacote primeiro. Depois de importar o pacote, veja como podemos criar hashmaps fracos em Java.

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

No código acima, criamos um hashmap fraco chamado numbers .

Aqui,

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

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

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

Capacidade e fator de carga padrão

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

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

Por padrão,

a capacidade do mapa será de 16
o fator de carga será de 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<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);
    }
}

Saída

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

Como podemos ver, quando a chave dois de um hashmap fraco é definido como null e realizar a coleta de lixo, a chave é removida.

É porque, ao contrário dos hashmaps, as chaves dos hashmaps fracos são de referência fraca modelo. Isso significa que a entrada de um mapa será 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<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);
    }
}

Saída

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

Aqui, quando a chave dois do hashmap está definido como null e realizar a coleta de lixo, a chave não é removida.

Isso ocorre porque, diferentemente dos hashmaps fracos, as chaves dos hashmaps são de referência forte modelo. Isso significa que a entrada de um mapa não é removida pelo coletor de lixo, mesmo que a chave dessa entrada não seja mais usada.

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

Criando WeakHashMap a partir 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<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);
    }
}

Saída

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

Métodos de WeakHashMap

O WeakHashMap classe 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 para este 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<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);
    }
}

Saída

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

Acessar elementos do WeakHashMap

1. Usando entrySet(), keySet() e values()

entrySet() - retorna um conjunto de todos os mapeamentos de chave/valor do mapa
keySet() - retorna um conjunto de todas as chaves do mapa
values() - retorna um conjunto de todos os valores do mapa

Por exemplo,

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

Saída

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

2. Usando get() e getOrDefault()

get() - Retorna o valor associado à chave especificada. Retorna null se a chave não for encontrada.
getOrDefault() - Retorna o valor associado à chave especificada. Retorna o valor padrão especificado se a chave não for encontrada.

Por exemplo,

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

    }
}

Saída

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

Remover elementos do WeakHashMap

remove(key) - retorna e remove a entrada associada à chave especificada do mapa
remove(key, value) - remove a entrada do mapa somente se a chave especificada for mapeada para o valor especificado e retornar um valor booleano

Por exemplo,

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

Saída

WeakHashMap: {Two=2, One=1}
Removed value: 2
Is the entry {One=3} removed? False
Updated WeakHashMap: {One=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).

Java LinkedHashMap Java EnumMap

Java