0Pricing
Java Academy · Aula

EnumSet e EnumMap

Use EnumSet e EnumMap para trabalhar com coleções eficientes e seguras quanto aos tipos baseadas em enumerações.

EnumSet e 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.

EnumSet e EnumMap

EnumSet e EnumMap são implementações de coleções altamente otimizadas para enumerações. Internamente, usam vetores de bits — são muito mais rápidas que HashSet/HashMap para chaves de enumeração.

EnumSet: criando conjuntos

EnumSet fornece métodos de fábrica para criar conjuntos de constantes de enumeração.

import java.util.*;

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

EnumSet<Day> weekdays  = EnumSet.range(Day.MON, Day.FRI);
EnumSet<Day> weekend   = EnumSet.of(Day.SAT, Day.SUN);
EnumSet<Day> allDays   = EnumSet.allOf(Day.class);
EnumSet<Day> noDays    = EnumSet.noneOf(Day.class);

System.out.println(weekdays); // [MON, TUE, WED, THU, FRI]
System.out.println(weekend);  // [SAT, SUN]
System.out.println(allDays.size()); // 7

EnumSet: operações de conjuntos

EnumSet oferece as operações padrão de conjuntos — união, interseção e complemento. Elas são extremamente rápidas graças à implementação com vetor de bits.

import java.util.*;

enum Permission { READ, WRITE, DELETE, ADMIN, EXPORT }

EnumSet<Permission> userPerms  = EnumSet.of(Permission.READ, Permission.WRITE);
EnumSet<Permission> adminPerms = EnumSet.allOf(Permission.class);

// Complement
EnumSet<Permission> missing = EnumSet.complementOf(userPerms);
System.out.println("Missing: " + missing);
// Missing: [DELETE, ADMIN, EXPORT]

// Intersection (retain)
EnumSet<Permission> shared = EnumSet.copyOf(userPerms);
shared.retainAll(adminPerms);
System.out.println("Shared: " + shared); // [READ, WRITE]

EnumMap: associando enumerações a valores

EnumMap usa internamente o ordinal da enumeração como índice de um vetor — a consulta O(1) é mais rápida que em HashMap.

import java.util.*;

enum Quarter { Q1, Q2, Q3, Q4 }

EnumMap<Quarter, Double> revenue = new EnumMap<>(Quarter.class);
revenue.put(Quarter.Q1, 125_000.0);
revenue.put(Quarter.Q2, 148_500.0);
revenue.put(Quarter.Q3, 132_750.0);
revenue.put(Quarter.Q4, 175_200.0);

double total = revenue.values().stream()
    .mapToDouble(Double::doubleValue).sum();
System.out.printf("Annual revenue: $%.0f%n", total);
// Annual revenue: $581450

EnumMap: iterando na ordem

EnumMap sempre itera sobre as chaves na ordem de declaração da enumeração — não na ordem de inserção nem na ordem do hash.

import java.util.*;

enum Month { JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC }

EnumMap<Month, Integer> salesUnits = new EnumMap<>(Month.class);
salesUnits.put(Month.MAR, 1420);
salesUnits.put(Month.JAN, 980);
salesUnits.put(Month.FEB, 1105);

// Iterates JAN, FEB, MAR (declaration order, not insertion order)
for (var entry : salesUnits.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
// JAN: 980
// FEB: 1105
// MAR: 1420

Sistema de permissões com EnumSet

Um sistema de permissões baseado em funções, usando EnumSet para verificações eficientes de permissões e um projeto de API limpo.

import java.util.*;

enum Permission { READ, WRITE, DELETE, PUBLISH, ADMIN }

record Role(String name, EnumSet<Permission> permissions) {
    boolean can(Permission p) { return permissions.contains(p); }
}

Role editor = new Role("Editor",
    EnumSet.of(Permission.READ, Permission.WRITE, Permission.PUBLISH));
Role viewer = new Role("Viewer",
    EnumSet.of(Permission.READ));

System.out.println(editor.can(Permission.WRITE));  // true
System.out.println(viewer.can(Permission.DELETE)); // false

Sinalizadores de recursos com EnumMap

EnumMap é perfeito para sistemas de sinalizadores de recursos: consulta O(1) rápida com chaves de enumeração.

import java.util.*;

enum Feature { DARK_MODE, BETA_EDITOR, AI_SUGGESTIONS, EXPORT_PDF }

class FeatureFlags {
    private final EnumMap<Feature, Boolean> flags = new EnumMap<>(Feature.class);

    public FeatureFlags() {
        for (Feature f : Feature.values()) flags.put(f, false);
    }

    public void enable(Feature f)  { flags.put(f, true); }
    public void disable(Feature f) { flags.put(f, false); }
    public boolean isEnabled(Feature f) { return flags.getOrDefault(f, false); }
}

FeatureFlags ff = new FeatureFlags();
ff.enable(Feature.DARK_MODE);
System.out.println(ff.isEnabled(Feature.DARK_MODE));      // true
System.out.println(ff.isEnabled(Feature.AI_SUGGESTIONS)); // false

Desempenho: EnumSet versus HashSet

EnumSet usa uma única máscara de bits long (para enumerações com <=64 constantes) — as operações são operações de bits O(1). HashSet usa compartimentos de hash — é mais lento e tem mais sobrecarga.

import java.util.*;

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

// EnumSet: bit operations on a long value
EnumSet<Day> workDays = EnumSet.range(Day.MON, Day.FRI);

// HashSet: hash table with boxing overhead
Set<Day> hashWorkDays = new HashSet<>(Arrays.asList(
    Day.MON, Day.TUE, Day.WED, Day.THU, Day.FRI));

// Both work, but EnumSet is ~5x faster for contains/add/remove
// and uses less memory
System.out.println(workDays.contains(Day.SAT));     // false
System.out.println(workDays.contains(Day.MON));     // true

EnumMap getOrDefault e computeIfAbsent

EnumMap oferece todas as operações de Map, incluindo getOrDefault, computeIfAbsent e merge.

import java.util.*;

enum Category { FOOD, ELECTRONICS, CLOTHING, BOOKS }

EnumMap<Category, List<String>> catalog = new EnumMap<>(Category.class);

// computeIfAbsent creates the list on first use
catalog.computeIfAbsent(Category.BOOKS, k -> new ArrayList<>()).add("Clean Code");
catalog.computeIfAbsent(Category.BOOKS, k -> new ArrayList<>()).add("Effective Java");
catalog.computeIfAbsent(Category.ELECTRONICS, k -> new ArrayList<>()).add("Laptop");

System.out.println(catalog.get(Category.BOOKS));
// [Clean Code, Effective Java]
System.out.println(catalog.getOrDefault(Category.FOOD, List.of()));
// []

Padrão multimap com EnumMap

Combine EnumMap com valores List para criar um multimap indexado por enumeração — uma forma eficiente de agrupar itens por categoria.

import java.util.*;
import java.util.stream.*;

enum Priority { LOW, NORMAL, HIGH, URGENT }
record Task(String name, Priority priority) {}

List<Task> tasks = List.of(
    new Task("Fix login bug", Priority.URGENT),
    new Task("Update docs",   Priority.LOW),
    new Task("Add unit tests",Priority.NORMAL),
    new Task("Deploy hotfix", Priority.URGENT)
);

// Group by priority into EnumMap
EnumMap<Priority, List<Task>> byPriority = tasks.stream()
    .collect(Collectors.groupingBy(Task::priority,
        () -> new EnumMap<>(Priority.class),
        Collectors.toList()));

byPriority.forEach((p, ts) ->
    System.out.println(p + ": " + ts.stream().map(Task::name).collect(Collectors.joining(", "))));

Quando usar EnumSet versus EnumMap

Resumo de quando escolher cada um:

  • EnumSet: quando você precisa de um conjunto de valores de enumeração — permissões, recursos ativos e dias selecionados
  • EnumMap: quando associa cada constante de enumeração a um valor — configuração por recurso, pontuação por nível e itens por categoria
  • Ambos: prefira-os a HashSet/HashMap para chaves de enumeração — são mais rápidos, usam menos memória e mantêm a ordem

Verificação rápida

Qual é a estrutura de dados interna usada por EnumSet para enumerações com 64 constantes ou menos?

Recapitulação: EnumSet e EnumMap

Principais conclusões:

  • EnumSet usa um vetor de bits — é extremamente rápido para conjuntos pequenos de enumeração
  • EnumSet.of(), range(), allOf() e noneOf() são métodos de fábrica comuns
  • EnumMap usa vetores indexados pelo ordinal — consulta O(1), ordenada pela declaração
  • Use EnumSet para conjuntos de permissões, sinalizadores de recursos e filtros de dias da semana
  • Use EnumMap para configurações por categoria, tabelas de pontuação e associações de recurso a valor
  • Ambos mantêm a ordem de declaração da enumeração e são mais eficientes que coleções baseadas em hash

Perguntas Frequentes

A aula “EnumSet e EnumMap” é grátis?

Sim — o texto completo de “EnumSet e 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 “EnumSet e EnumMap”?

Use EnumSet e EnumMap para trabalhar com coleções eficientes e seguras quanto aos tipos baseadas em enumerações. 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 “EnumSet e 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

  1. Definição e Uso de Enumerações
  2. Enumerações com Campos e Métodos
  3. Expressões switch com Enumerações
  4. EnumSet e EnumMap
← Voltar para Java Academy