Java EnumMap

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

O EnumMap A classe da estrutura de coleções Java fornece uma implementação de mapa para elementos de uma enumeração.

Em EnumMap , os elementos enum são usados como chaves . Ele implementa a interface Map.

Antes de aprendermos sobre EnumMap , certifique-se de saber sobre o Java Enums.

Criando um EnumMap

Para criar um mapa enum, devemos importar o java.util.EnumMap pacote primeiro. Depois de importar o pacote, veja como podemos criar mapas enum em Java.

enum Size {
    SMALL, MEDIUM, LARGE, EXTRALARGE
}

EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

No exemplo acima, criamos um mapa enum chamado sizes .

Aqui,

Tamanho - chaves da enumeração que mapeia para valores
Inteiro - valores do mapa enum associado às chaves correspondentes

Métodos de EnumMap

O EnumMap class fornece métodos que nos permitem executar vários elementos nos mapas enum.

Inserir Elementos no EnumMap

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

Por exemplo,

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class);

        // Using the put() Method
        sizes1.put(Size.SMALL, 28);
        sizes1.put(Size.MEDIUM, 32);
        System.out.println("EnumMap1: " + sizes1);

        EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class);

        // Using the putAll() Method
        sizes2.putAll(sizes1);
        sizes2.put(Size.LARGE, 36);
        System.out.println("EnumMap2: " + sizes2);
    }
}

Saída

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

No exemplo acima, usamos o putAll() método para inserir todos os elementos de um mapa enum sizes1 para um mapa enum de sizes2 .

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

Acessar elementos do EnumMap

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

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

Por exemplo,

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the entrySet() Method
        System.out.println("Key/Value mappings: " + sizes.entrySet());

        // Using the keySet() Method
        System.out.println("Keys: " + sizes.keySet());

        // Using the values() Method
        System.out.println("Values: " + sizes.values());
    }
}

Saída

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Key/Value mappings: [SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40]
Keys: [SMALL, MEDIUM, LARGE, EXTRALARGE]
Values: [28, 32, 36, 40]

2. Usando o método get()

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

Por exemplo,

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the get() Method
        int value = sizes.get(Size.MEDIUM);
        System.out.println("Value of MEDIUM: " + value);
    }
}

Saída

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Value of MEDIUM: 32

Remover elementos do EnumMap

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.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the remove() Method
        int value = sizes.remove(Size.MEDIUM);
        System.out.println("Removed Value: " + value);

        boolean result = sizes.remove(Size.SMALL, 28);
        System.out.println("Is the entry {SMALL=28} removed? " + result);

        System.out.println("Updated EnumMap: " + sizes);
    }
}

Saída

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Removed Value: 32
Is the entry {SMALL=28} removed? True
Updated EnumMap: {LARGE=36, EXTRALARGE=40}

Substituir elementos do EnumMap

replace(key, value) - substitui o valor associado à chave especificada pelo novo valor
replace(key, old, new) - substitui o antigo valor com o novo valor somente se o antigo o valor já está associado à chave especificada
replaceAll(function) - substitui cada valor do mapa pelo resultado da função especificada

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the replace() Method
        sizes.replace(Size.MEDIUM, 30);
        sizes.replace(Size.LARGE, 36, 34);
        System.out.println("EnumMap using replace(): " + sizes);

        // Using the replaceAll() Method
        sizes.replaceAll((key, oldValue) -> oldValue + 3);
        System.out.println("EnumMap using replaceAll(): " + sizes);
    }
}

Saída

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

No programa acima, observe a declaração

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

Aqui, o método acessa todas as entradas do mapa. Em seguida, ele substitui todos os valores pelos novos valores fornecidos pelas expressões lambda.

Outros métodos

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

EnumSet vs. EnumMap

Tanto o EnumSet quanto o EnumMap A classe fornece estruturas de dados para armazenar valores de enumeração. No entanto, existem algumas diferenças importantes entre eles.

O enum set é representado internamente como uma sequência de bits, enquanto o enum map é representado internamente como arrays.
O conjunto de enumerações é criado usando seus métodos predefinidos, como allOf() , noneOf() , of() , etc. No entanto, um mapa enum é criado usando seu construtor.

Interfaces clonáveis e serializáveis

O EnumMap classe também implementa Cloneable e Serializable interfaces.

Interface Clonável

Ele permite que o EnumMap class para fazer uma cópia das instâncias da classe.

Interface serializável

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

O Serializable interface permite que as classes sejam serializadas. Isso significa que objetos das classes que implementam Serializable podem ser convertidos em bits ou bytes.

Java WeakHashMap Interface Java SortedMap

Java