Java Academy · Aula

EnumMap

Mapas eficientes indexados por enums.

EnumMap é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que é EnumMap

EnumMap é um Map especializado cujas chaves são constantes de um único tipo de enumeração.

Internamente, ele é baseado em um vetor indexado pelo ordinal da constante. Isso torna as pesquisas e inserções extremamente rápidas, sem operações de espalhamento.

import java.util.EnumMap;
import java.util.Map;

public class Main {
    enum Day { MON, TUE, WED }
    public static void main(String[] args) {
        Map<Day, String> plan = new EnumMap<>(Day.class);
        plan.put(Day.MON, "Gym");
        plan.put(Day.WED, "Swim");
        System.out.println(plan);
    }
}

A construção exige a classe

Um EnumMap precisa conhecer antecipadamente o tipo das chaves, portanto o construtor recebe o objeto da classe: new EnumMap<>(Day.class).

É assim que ele dimensiona seu vetor interno de acordo com o número de constantes.

import java.util.EnumMap;

public class Main {
    enum Priority { LOW, MEDIUM, HIGH }
    public static void main(String[] args) {
        EnumMap<Priority, Integer> counts = new EnumMap<>(Priority.class);
        counts.put(Priority.HIGH, 5);
        System.out.println(counts.get(Priority.HIGH));
    }
}

Velocidade baseada em vetor

Como as chaves são armazenadas em array[ordinal], get e put são acessos diretos ao vetor, mais rápidos que o espalhamento e o percurso pelos compartimentos do HashMap.

Não há encaixotamento da chave nem chamada a hashCode.

import java.util.EnumMap;

public class Main {
    enum Slot { A, B, C, D }
    public static void main(String[] args) {
        EnumMap<Slot, Integer> m = new EnumMap<>(Slot.class);
        for (Slot s : Slot.values()) m.put(s, s.ordinal() * 10);
        System.out.println(m.get(Slot.C));
    }
}

Iteração na ordem das chaves

EnumMap percorre as entradas na ordem natural das chaves, que é a ordem de declaração.

Isso proporciona uma saída estável e previsível, ao contrário de HashMap.

import java.util.EnumMap;
import java.util.Map;

public class Main {
    enum Phase { PLAN, BUILD, SHIP }
    public static void main(String[] args) {
        Map<Phase, Integer> hours = new EnumMap<>(Phase.class);
        hours.put(Phase.SHIP, 3);
        hours.put(Phase.PLAN, 8);
        hours.put(Phase.BUILD, 20);
        for (Map.Entry<Phase, Integer> e : hours.entrySet()) {
            System.out.println(e.getKey() + " = " + e.getValue());
        }
    }
}

Chaves nulas são proibidas

EnumMap não permite chaves nulas; uma chave nula lança NullPointerException.

Valores nulos são permitidos, assim como em outros mapas.

import java.util.EnumMap;

public class Main {
    enum K { A, B }
    public static void main(String[] args) {
        EnumMap<K, String> m = new EnumMap<>(K.class);
        m.put(K.A, null); // null value is fine
        System.out.println("A -> " + m.get(K.A));
        System.out.println("contains A: " + m.containsKey(K.A));
    }
}

Agrupamento com EnumMap

Um uso comum é contar ou agrupar por uma categoria de enumeração. merge torna a contagem concisa.

import java.util.EnumMap;
import java.util.List;
import java.util.Map;

public class Main {
    enum Type { FRUIT, VEG, MEAT }
    record Item(String name, Type type) {}
    public static void main(String[] args) {
        List<Item> items = List.of(new Item("apple", Type.FRUIT), new Item("pear", Type.FRUIT), new Item("beef", Type.MEAT));
        Map<Type, Integer> counts = new EnumMap<>(Type.class);
        for (Item i : items) counts.merge(i.type(), 1, Integer::sum);
        System.out.println(counts);
    }
}

getOrDefault e computeIfAbsent

Todos os métodos padrão de Map funcionam. getOrDefault evita verificações de nulo, e computeIfAbsent cria valores sob demanda.

import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;

public class Main {
    enum Group { A, B }
    public static void main(String[] args) {
        Map<Group, List<String>> m = new EnumMap<>(Group.class);
        m.computeIfAbsent(Group.A, k -> new ArrayList<>()).add("first");
        System.out.println(m);
        System.out.println(m.getOrDefault(Group.B, List.of()));
    }
}

Construtor de cópia

EnumMap tem um construtor de cópia que aceita outro Map. Se a origem for um EnumMap, o tipo da chave será inferido a partir dela.

import java.util.EnumMap;
import java.util.Map;

public class Main {
    enum K { X, Y }
    public static void main(String[] args) {
        EnumMap<K, Integer> a = new EnumMap<>(K.class);
        a.put(K.X, 1);
        EnumMap<K, Integer> b = new EnumMap<>(a);
        b.put(K.Y, 2);
        System.out.println("copy: " + b);
    }
}

EnumMap versus vetores de ordinal

Antes do EnumMap, as pessoas usavam vetores brutos indexados por ordinal(). Isso é frágil e inseguro.

EnumMap oferece a mesma velocidade dos vetores, com segurança de tipos, segurança de limites e uma API Map limpa.

import java.util.EnumMap;
import java.util.Map;

public class Main {
    enum Season { SPRING, SUMMER, FALL, WINTER }
    public static void main(String[] args) {
        Map<Season, String> mood = new EnumMap<>(Season.class);
        mood.put(Season.SUMMER, "sunny");
        // Safer and clearer than String[] indexed by ordinal
        System.out.println(mood.get(Season.SUMMER));
    }
}

EnumMaps aninhados

Você pode aninhar EnumMaps para modelar uma matriz indexada por duas enumerações, como uma tabela de transições de estados.

import java.util.EnumMap;
import java.util.Map;

public class Main {
    enum State { SOLID, LIQUID, GAS }
    enum Transition { MELT, FREEZE }
    public static void main(String[] args) {
        Map<State, Map<Transition, State>> table = new EnumMap<>(State.class);
        Map<Transition, State> solid = new EnumMap<>(Transition.class);
        solid.put(Transition.MELT, State.LIQUID);
        table.put(State.SOLID, solid);
        System.out.println(table.get(State.SOLID).get(Transition.MELT));
    }
}

Escolhendo o tipo certo

Regra geral:

As chaves são constantes de enumeração e você quer um mapa: use EnumMap.
Você quer um conjunto de enumerações: use EnumSet.
As chaves são objetos arbitrários: use HashMap.

import java.util.EnumMap;
import java.util.Map;

public class Main {
    enum Level { DEBUG, INFO, WARN, ERROR }
    public static void main(String[] args) {
        Map<Level, Integer> thresholds = new EnumMap<>(Level.class);
        for (Level l : Level.values()) thresholds.put(l, l.ordinal() * 100);
        System.out.println(thresholds);
    }
}

Verificação rápida

Teste seus conhecimentos sobre EnumMap.

Recapitulação

Você aprendeu sobre EnumMap:

Um Map baseado em vetor, indexado por constantes de enumeração.
O construtor recebe a classe da chave; chaves nulas não são permitidas.
Percorre os elementos na ordem de declaração.
O substituto seguro e rápido para vetores indexados por ordinal.

Você concluiu o curso avançado de enumerações.

import java.util.EnumMap;

public class Main {
    enum K { A }
    public static void main(String[] args) {
        EnumMap<K, String> m = new EnumMap<>(K.class);
        m.put(K.A, "done");
        System.out.println("EnumMap course complete: " + m.get(K.A));
    }
}

Perguntas Frequentes

A aula “EnumMap” é grátis?

Sim — o texto completo de “EnumMap” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “EnumMap”?

Mapas eficientes indexados por enums. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “EnumMap”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy