Java EnumMap

Neste tutorial, vamos aprender sobre a classe Java EnumMap e suas operações com exemplos.

A classe EnumMap da Java Collection Framework fornece uma implementação de mapeamento para elementos de enumeração.

No EnumMap, os elementos do enum são usados comoChaves. Ele implementaInterface Map.

Antes de aprender EnumMap, certifique-se de entenderEnumerados Java.

Crie um EnumMap

Para criar um mapeamento de enumeração, devemos primeiro importar o pacote java.util.EnumMap. Após a importação do pacote, podemos usar Java para criar um mapeamento de enumeração.

enum Size {
　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
}
EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

No exemplo acima, criamos um mapeamento de enumeração chamado sizes.

Aqui,

• Size - Mapeadas para valores de enumeraçãoChaves

• Integer- Associados ao mapeamento de enumeração correspondenteValores

Métodos do EnumMap

A classe EnumMap fornece vários métodos que permitem executar várias operações no mapeamento de enumeração.

Insira o elemento no EnumMap

• put() - Insira a chave especificada/Insira os itens do mapeamento de valores (itens) no mapeamento de enumeração

• putAll() - Insira todos os itens do mapeamento especificado neste mapeamento

Por exemplo,

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Crie um EnumMap para o enum size
　　　　　　　　EnumMap<Size, Integer> sizes1　= new EnumMap<>(Size.class);
　　　　　　　　//　Usar o método put()
　　　　　　　　sizes1.put(Size.SMALL,　28);
　　　　　　　　sizes1.put(Size.MEDIUM,　32);
　　　　　　　　System.out.println("EnumMap1: "{"　+　sizes1);
　　　　　　　　EnumMap<Size, Integer> sizes2　= new EnumMap<>(Size.class);
　　　　　　　　//　Usar o método putAll()
　　　　　　　　sizes2.putAll(sizes1);
　　　　　　　　sizes2.put(Size.LARGE,　36);
　　　　　　　　System.out.println("EnumMap2: "{"　+　sizes2);
　　　　}
}

Resultados de saída

EnumMap1: {SMALL=28, MEDIUM=32}
EnumMap2: {SMALL=28, MEDIUM=32, LARGE=36}

No exemplo acima, usamos o método putAll() para inserir o mapeamento de enumeração size1de todos os elementos em size2do mapeamento de enumeração.

Também pode usar putAll() para inserir elementos de outros mapeamentos (como HashMap, TreeMap, etc.) no mapeamento de enumeração. No entanto, todos os mapeamentos devem ter o mesmo tipo de enumeração.

Acessar elementos do EnumMap

1Use entrySet(), keySet() e values()

• entrySet() - Retorna todas as chaves do mapeamento de enumeração/A coleção de valores mapeados (itens)

• keySet() - Retorna a coleção de todos os chaves do mapeamento de enumeração

• values() - Retorne a coleção de todos os valores do mapeamento enumerado

Por exemplo,

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar EnumMap para o enum Size
　　　　　　　　EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
　　　　　　　　sizes.put(Size.SMALL,　28);
　　　　　　　　sizes.put(Size.MEDIUM,　32);
　　　　　　　　sizes.put(Size.LARGE,　36);
　　　　　　　　sizes.put(Size.EXTRALARGE,　40);
　　　　　　　　System.out.println("EnumMap: ")　+　sizes);
　　　　　　　　//　Usar o método entrySet()
　　　　　　　　System.out.println("Chave/Mapeamento de Valores:　+　sizes.entrySet());
　　　　　　　　//　Usar o método keySet()
　　　　　　　　System.out.println("Chaves: ",　+　sizes.keySet());
　　　　　　　　//　Usar o método values()
　　　　　　　　System.out.println("Valores: ",　+　sizes.values());
　　　　}
}

Resultados de saída

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Chave/Mapeamento de Valores: [SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40]
Chaves: [SMALL, MEDIUM, LARGE, EXTRALARGE]
Valores: [28,　32,　36,　40]

2.Usar o método get()

O método get() retorna o valor associado à chave especificada. Se a chave especificada não for encontrada, retorna null.

Por exemplo,

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar EnumMap para o enum Size
　　　　　　　　EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
　　　　　　　　sizes.put(Size.SMALL,　28);
　　　　　　　　sizes.put(Size.MEDIUM,　32);
　　　　　　　　sizes.put(Size.LARGE,　36);
　　　　　　　　sizes.put(Size.EXTRALARGE,　40);
　　　　　　　　System.out.println("EnumMap: ")　+　sizes);
　　　　　　　　//　Usar o método get()
　　　　　　　　int value = sizes.get(Size.MEDIUM);
　　　　　　　　System.out.println("Valor de MEDIUM: ",　+　value);
　　　　}
}

Resultados de saída

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Valor de MEDIUM:　32

Remova o elemento EnumMap

• remove(key) - Retorne e remova o item mapeado associado à chave especificada

• remove(key, value) - Remova o item do mapeamento apenas quando a chave especificada estiver mapeada para o valor especificado e retornar um valor booleano

Por exemplo,

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar EnumMap para o enum Size
　　　　　　　　EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
　　　　　　　　sizes.put(Size.SMALL,　28);
　　　　　　　　sizes.put(Size.MEDIUM,　32);
　　　　　　　　sizes.put(Size.LARGE,　36);
　　　　　　　　sizes.put(Size.EXTRALARGE,　40);
　　　　　　　　System.out.println("EnumMap: ")　+　sizes);
　　　　　　　　//　Usar o método remove()
　　　　　　　　int value = sizes.remove(Size.MEDIUM);
　　　　　　　　System.out.println("Valor removido: ",　+　value);
　　　　　　　　boolean result = sizes.remove(Size.SMALL,　28);
　　　　　　　　System.out.println("Item {SMALL=",28} foi removido? "　+　result);
　　　　　　　　System.out.println("EnumMap atualizado: ",　+　sizes);
　　　　}
}

Resultados de saída

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Remover valor:　32
Item {SMALL=28} foi removido? True
EnumMap atualizado: {LARGE=36, EXTRALARGE=40}

Substitua o elemento EnumMap

• replace(key, value) - Substitua o valor associado à chave key pelo valor value

• replace(key, old, new) -　 Substitua o valor antigo com o novo apenas quando o valor antigo já estiver associado à chave especificada

• replaceAll(function) - Substitua cada valor mapeado com o resultado de uma função específica

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　SMALL, MEDIUM, LARGE, EXTRALARGE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//　Criar EnumMap para o enum Size
　　　　　　　　EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
　　　　　　　　sizes.put(Size.SMALL,　28);
　　　　　　　　sizes.put(Size.MEDIUM,　32);
　　　　　　　　sizes.put(Size.LARGE,　36);
　　　　　　　　sizes.put(Size.EXTRALARGE,　40);
　　　　　　　　System.out.println("EnumMap: ")　+　sizes);
　　　　　　　　//　Usar método replace()
　　　　　　　　sizes.replace(Size.MEDIUM,　30);
　　　　　　　　sizes.replace(Size.LARGE,　36,　34);
　　　　　　　　System.out.println("Uso do EnumMap replace(): ")　+　sizes);
　　　　　　　　//　Usar método replaceAll()
　　　　　　　　sizes.replaceAll((key, oldValue)　-> oldValue　+　3);
　　　　　　　　System.out.println("Uso do EnumMap replaceAll(): ")　+　sizes);
　　　　}
}

Resultados de saída

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Uso do EnumMap replace(): {SMALL=28, MEDIUM=30, LARGE=34, EXTRALARGE=40}
Uso do EnumMap replaceAll(): {SMALL=31, MEDIUM=33, LARGE=37, EXTRALARGE=43}

Na programa acima, note as seguintes instruções

sizes.replaceAll((key, oldValue)　-> oldValue　+　3);

Aqui, o método acessa todos os itens do map. Em seguida, ele substitui todas as valores porExpressão lambdaNovos valores fornecidos.

Outros métodos

Diferença entre EnumSet e EnumMap

EnumSetE a classe EnumMap ambos fornecem estruturas de dados para armazenar valores de enumeração. No entanto, existem algumas diferenças principais entre eles.

• Os conjuntos de enumeração são representados internamente como sequências de bits, enquanto os mapeamentos de enumeração são representados internamente como arrays.

• Os conjuntos de enumeração são criados usando métodos pré-definidos, como allOf(), noneOf(), of(), etc. No entanto, o mapeamento de enumeração é criado usando seu construtor.

Interfaces Cloneable e Serializable

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

Cloneable ClonagemInterface

Permite que a classe EnumMap copie instâncias da classe.

Interface serializável

Cada vez que precisar transmitir um objeto Java pela rede, é necessário converter o objeto em bits ou bytes. Isso porque os objetos Java não podem ser transmitidos pela rede.

A interface Serializable permite que a classe seja serializada. Isso significa que a Serializable pode converter os objetos da classe implementada em bits ou bytes.