Dominando Java EnumMap: Mapeamento Chave-Valor Eficiente com Enums

Java EnumMap

Neste tutorial, aprenderemos sobre a classe Java EnumMap e suas operações com a ajuda de exemplos.

A classe EnumMap do framework de coleções do Java fornece uma implementação de mapa para elementos de um enum.

No EnumMap, elementos de enum são usados como chaves. Ela implementa a interface Map.

Antes de aprender sobre EnumMap, certifique-se de conhecer Java Enums.

Criando um EnumMap

Para criar um enum map, devemos importar o pacote java.util.EnumMap primeiro. Uma vez importado, aqui está como podemos criar enum maps no Java.

enum Tamanho { PEQUENO, MEDIO, GRANDE, EXTRAGRANDE }
EnumMap<Tamanho, Integer> tamanhos = new EnumMap<>(Tamanho.class);

No exemplo acima, criamos um enum map chamado tamanhos.

Aqui,

• Tamanho - chaves do enum que mapeiam para valores
• Integer - valores do enum map associados com as chaves correspondentes

Métodos do EnumMap

A classe EnumMap fornece métodos que nos permitem realizar várias operações nos enum maps.

Inserir Elementos no EnumMap

• put() - insere o mapeamento chave/valor (entrada) especificado no enum map
• putAll() - insere todas as entradas de um mapa especificado neste mapa

Por exemplo,

import java.util.EnumMap;
class Main {
    enum Tamanho { PEQUENO, MEDIO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Criando um EnumMap do enum Tamanho
        EnumMap<Tamanho, Integer> tamanhos1 = new EnumMap<>(Tamanho.class);
        // Usando o método put()
        tamanhos1.put(Tamanho.PEQUENO, 28);
        tamanhos1.put(Tamanho.MEDIO, 32);
        System.out.println("EnumMap1: " + tamanhos1);
        EnumMap<Tamanho, Integer> tamanhos2 = new EnumMap<>(Tamanho.class);
        // Usando o método putAll()
        tamanhos2.putAll(tamanhos1);
        tamanhos2.put(Tamanho.GRANDE, 36);
        System.out.println("EnumMap2: " + tamanhos2);
    }
}

Saída

EnumMap1: {PEQUENO=28, MEDIO=32} EnumMap2: {PEQUENO=28, MEDIO=32, GRANDE=36}

No exemplo acima, usamos o método putAll() para inserir todos os elementos de um enum map tamanhos1 em um enum map de tamanhos2.

Também é possível inserir elementos de outros mapas como HashMap, TreeMap, etc. em um enum map usando putAll(). No entanto, todos os mapas devem ser do mesmo tipo de enum.

Acessar Elementos do EnumMap

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

• entrySet() - retorna um conjunto de todos os mapeamentos chave/valor (entrada) de um enum map
• keySet() - retorna um conjunto de todas as chaves de um enum map
• values() - retorna um conjunto de todos os valores de um enum map

Por exemplo,

import java.util.EnumMap;
class Main {
    enum Tamanho { PEQUENO, MEDIO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Criando um EnumMap do enum Tamanho
        EnumMap<Tamanho, Integer> tamanhos = new EnumMap<>(Tamanho.class);
        tamanhos.put(Tamanho.PEQUENO, 28);
        tamanhos.put(Tamanho.MEDIO, 32);
        tamanhos.put(Tamanho.GRANDE, 36);
        tamanhos.put(Tamanho.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanhos);
        // Usando o método entrySet()
        System.out.println("Mapeamentos Chave/Valor: " + tamanhos.entrySet());
        // Usando o método keySet()
        System.out.println("Chaves: " + tamanhos.keySet());
        // Usando o método values()
        System.out.println("Valores: " + tamanhos.values());
    }
}

Saída

EnumMap: {PEQUENO=28, MEDIO=32, GRANDE=36, EXTRAGRANDE=40} Mapeamentos Chave/Valor: [PEQUENO=28, MEDIO=32, GRANDE=36, EXTRAGRANDE=40] Chaves: [PEQUENO, MEDIO, GRANDE, EXTRAGRANDE] Valores: [28, 32, 36, 40]

2. Usando o Método get()

O método get() retorna o valor associado com a chave especificada. Retorna null se a chave especificada não for encontrada.

Por exemplo,

import java.util.EnumMap;
class Main {
    enum Tamanho { PEQUENO, MEDIO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Criando um EnumMap do enum Tamanho
        EnumMap<Tamanho, Integer> tamanhos = new EnumMap<>(Tamanho.class);
        tamanhos.put(Tamanho.PEQUENO, 28);
        tamanhos.put(Tamanho.MEDIO, 32);
        tamanhos.put(Tamanho.GRANDE, 36);
        tamanhos.put(Tamanho.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanhos);
        // Usando o método get()
        int valor = tamanhos.get(Tamanho.MEDIO);
        System.out.println("Valor de MEDIO: " + valor);
    }
}

Saída

EnumMap: {PEQUENO=28, MEDIO=32, GRANDE=36, EXTRAGRANDE=40} Valor de MEDIO: 32

Remover Elementos do EnumMap

• remove(chave) - retorna e remove a entrada associada com a chave especificada do mapa
• remove(chave, valor) - remove a entrada do mapa apenas se a chave especificada mapeou para o valor especificado e retorna um valor booleano

Por exemplo,

import java.util.EnumMap;
class Main {
    enum Tamanho { PEQUENO, MEDIO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Criando um EnumMap do enum Tamanho
        EnumMap<Tamanho, Integer> tamanhos = new EnumMap<>(Tamanho.class);
        tamanhos.put(Tamanho.PEQUENO, 28);
        tamanhos.put(Tamanho.MEDIO, 32);
        tamanhos.put(Tamanho.GRANDE, 36);
        tamanhos.put(Tamanho.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanhos);
        // Usando o método remove()
        int valor = tamanhos.remove(Tamanho.MEDIO);
        System.out.println("Valor Removido: " + valor);
        boolean resultado = tamanhos.remove(Tamanho.PEQUENO, 28);
        System.out.println("A entrada {PEQUENO=28} foi removida? " + resultado);
        System.out.println("EnumMap Atualizado: " + tamanhos);
    }
}

Saída

EnumMap: {PEQUENO=28, MEDIO=32, GRANDE=36, EXTRAGRANDE=40} Valor Removido: 32 A entrada {PEQUENO=28} foi removida? true EnumMap Atualizado: {GRANDE=36, EXTRAGRANDE=40}

Substituir Elementos do EnumMap

• replace(chave, valor) - substitui o valor associado com a chave especificada pelo novo valor
• replace(chave, antigo, novo) - substitui o valor antigo pelo novo apenas se o valor antigo já estiver associado com a chave especificada
• replaceAll(funcao) - substitui cada valor do mapa com o resultado da funcao especificada

import java.util.EnumMap;
class Main {
    enum Tamanho { PEQUENO, MEDIO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Criando um EnumMap do enum Tamanho
        EnumMap<Tamanho, Integer> tamanhos = new EnumMap<>(Tamanho.class);
        tamanhos.put(Tamanho.PEQUENO, 28);
        tamanhos.put(Tamanho.MEDIO, 32);
        tamanhos.put(Tamanho.GRANDE, 36);
        tamanhos.put(Tamanho.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanhos);
        // Usando o método replace()
        tamanhos.replace(Tamanho.MEDIO, 30);
        tamanhos.replace(Tamanho.GRANDE, 36, 34);
        System.out.println("EnumMap usando replace(): " + tamanhos);
        // Usando o método replaceAll()
        tamanhos.replaceAll((chave, valorAntigo) -> valorAntigo + 3);
        System.out.println("EnumMap usando replaceAll(): " + tamanhos);
    }
}

Saída

EnumMap: {PEQUENO=28, MEDIO=32, GRANDE=36, EXTRAGRANDE=40} EnumMap usando replace(): {PEQUENO=28, MEDIO=30, GRANDE=34, EXTRAGRANDE=40} EnumMap usando replaceAll(): {PEQUENO=31, MEDIO=33, GRANDE=37, EXTRAGRANDE=43}

No programa acima, observe a declaração

tamanhos.replaceAll((chave, valorAntigo) -> valorAntigo + 3);

Aqui, o método acessa todas as entradas do mapa. Ele então substitui todos os valores com os novos valores fornecidos pelas expressões lambda.

Outros Métodos

Método	Descrição
clone()	Cria uma cópia do EnumMap
containsKey()	Busca o EnumMap pela chave especificada e retorna resultado booleano
containsValue()	Busca o EnumMap pelo valor especificado e retorna resultado booleano
size()	Retorna o tamanho do EnumMap
clear()	Remove todas as entradas do EnumMap

EnumSet Vs. EnumMap

Tanto o EnumSet quanto a classe EnumMap fornecem estruturas de dados para armazenar valores de enum. No entanto, existem algumas diferenças principais entre eles.

• Enum set é representado internamente como uma sequência de bits, enquanto o enum map é representado internamente como arrays.
• Enum set é criado usando seus métodos predefinidos como allOf(), noneOf(), of(), etc. No entanto, um enum map é criado usando seu construtor.

Interfaces Cloneable e Serializable

A classe EnumMap também implementa as interfaces Cloneable e Serializable.

Interface Cloneable

Permite que a classe EnumMap faça uma cópia de instâncias da classe.

Interface Serializable

Sempre que objetos Java precisam ser transmitidos por uma rede, objetos precisam ser convertidos em bits ou bytes. Isso porque objetos Java não podem ser transmitidos pela rede.

A interface Serializable permite que classes sejam serializadas. Isso significa que objetos de classes implementando Serializable podem ser convertidos em bits ou bytes.