0Pricing
Java Academy · Aula

TreeMap: Pares Ordenados de Chave e Valor

Use TreeMap para manter a ordem e navegar com firstKey, lastKey, floorKey e ceilingKey.

TreeMap: Pares Ordenados de Chave e Valor é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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 é uma TreeMap?

TreeMap é uma implementação de mapa ordenado baseada em uma árvore rubro-negra. As chaves são mantidas em ordem natural crescente (ou na ordem de um comparador personalizado). Todas as operações básicas são O(log n).

import java.util.TreeMap;

TreeMap<String, Integer> scores = new TreeMap<>();
scores.put("Charlie", 85);
scores.put("Alice", 92);
scores.put("Bob", 78);

// Iteration is in key order: Alice, Bob, Charlie
for (var entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

firstKey, lastKey, floorKey, ceilingKey

A interface NavigableMap de TreeMap expõe métodos de navegação para encontrar chaves relativas a um determinado valor:

TreeMap<Integer, String> map = new TreeMap<>();
map.put(10, "ten"); map.put(20, "twenty"); map.put(30, "thirty"); map.put(40, "forty");

System.out.println(map.firstKey());       // 10
System.out.println(map.lastKey());        // 40
System.out.println(map.floorKey(25));     // 20 (largest key ≤ 25)
System.out.println(map.ceilingKey(25));   // 30 (smallest key ≥ 25)
System.out.println(map.lowerKey(20));     // 10 (strictly less)
System.out.println(map.higherKey(20));    // 30 (strictly greater)

Navegando pelas entradas

floorEntry, ceilingEntry, firstEntry, lastEntry retornam o Map.Entry completo, em vez de apenas a chave:

TreeMap<Integer, String> prices = new TreeMap<>();
prices.put(100, "Budget"); prices.put(300, "Standard"); prices.put(700, "Premium");

var entry = prices.floorEntry(350);
System.out.println(entry.getKey() + ": " + entry.getValue()); // 300: Standard

var top = prices.lastEntry();
System.out.println(top.getValue()); // Premium

subMap, headMap, tailMap

Extraia visualizações de intervalos de uma TreeMap. Essas visualizações são apoiadas pelo mapa original — as alterações em uma se refletem na outra.

TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 10; i++) map.put(i, "v"+i);

// Keys from 3 (inclusive) to 7 (exclusive)
System.out.println(map.subMap(3, 7));   // {3=v3, 4=v4, 5=v5, 6=v6}

// Keys strictly less than 5
System.out.println(map.headMap(5));     // {1=v1, 2=v2, 3=v3, 4=v4}

// Keys >= 7
System.out.println(map.tailMap(7));     // {7=v7, 8=v8, 9=v9, 10=v10}

Limites inclusivos e exclusivos

Use as variantes sobrecarregadas para controlar os limites com precisão:

TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 10; i++) map.put(i*10, "v"+i);

// From 30 (inclusive) to 60 (inclusive)
System.out.println(map.subMap(30, true, 60, true));
// {30=v3, 40=v4, 50=v5, 60=v6}

Ordem descendente

Use descendingMap() ou descendingKeySet() para iterar pelas chaves em ordem inversa:

TreeMap<String, Integer> tm = new TreeMap<>();
tm.put("A", 1); tm.put("C", 3); tm.put("B", 2);

for (String key : tm.descendingKeySet()) {
    System.out.print(key + " "); // C B A
}

pollFirstEntry e pollLastEntry

Remova e retorne atomicamente a primeira ou a última entrada — útil para criar mapas de prioridades:

TreeMap<Integer, String> events = new TreeMap<>();
events.put(8, "Breakfast");
events.put(12, "Lunch");
events.put(18, "Dinner");

var first = events.pollFirstEntry(); // removes 8=Breakfast
System.out.println(first.getValue() + " removed");
System.out.println(events.firstKey()); // 12

Caso de uso: tabela de classificação

Uma tabela de classificação precisa manter os jogadores ordenados pela pontuação. TreeMap ordena automaticamente pelas chaves:

TreeMap<Integer, String> leaderboard = new TreeMap<>(Comparator.reverseOrder());
leaderboard.put(1200, "Alice");
leaderboard.put(1500, "Bob");
leaderboard.put(900, "Carol");

int rank = 1;
for (var e : leaderboard.entrySet()) {
    System.out.println(rank++ + ". " + e.getValue() + " (" + e.getKey() + ")");
}
// 1. Bob (1500)
// 2. Alice (1200)
// 3. Carol (900)

Caso de uso: agendador de eventos

Associe marcas de tempo a eventos — use ceilingEntry para encontrar o próximo evento agendado depois de um determinado horário:

import java.time.LocalTime;
TreeMap<LocalTime, String> schedule = new TreeMap<>();
schedule.put(LocalTime.of(9,0), "Standup");
schedule.put(LocalTime.of(14,0), "Review");
schedule.put(LocalTime.of(17,0), "Retro");

LocalTime now = LocalTime.of(11, 30);
var next = schedule.ceilingEntry(now);
System.out.println("Next: " + next.getValue()); // Review

Desempenho de TreeMap versus HashMap

Comparação principal:

  • HashMap: get/put em O(1) na média; sem ordenação
  • TreeMap: get/put em O(log n); ordenada pelas chaves
  • LinkedHashMap: O(1) na média; ordenada pela inserção

Use TreeMap quando precisar de chaves ordenadas ou consultas por intervalo. HashMap é mais rápida para uma simples busca por chave.

Segurança em relação a threads

TreeMap NÃO é segura para uso com várias threads. Para acesso simultâneo, use ConcurrentSkipListMap, que também mantém a ordem e oferece operações O(log n), além de permitir leituras e gravações simultâneas.

Verificação rápida

Você tem uma TreeMap<Integer, String> com as chaves {10, 20, 30, 40}. O que map.floorKey(25) retorna?

Recapitulação: TreeMap

Principais conclusões:

  • TreeMap mantém as chaves em ordem ordenada (crescente) por meio de uma árvore rubro-negra
  • Todas as operações são O(log n)
  • Navegação: firstKey, lastKey, floorKey, ceilingKey, lowerKey, higherKey
  • Visualizações de intervalos: subMap, headMap, tailMap (visualizações apoiadas pelo mapa)
  • Use ConcurrentSkipListMap para mapas ordenados seguros para uso com várias threads

Perguntas Frequentes

A aula “TreeMap: Pares Ordenados de Chave e Valor” é grátis?

Sim — o texto completo de “TreeMap: Pares Ordenados de Chave e Valor” é 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 “TreeMap: Pares Ordenados de Chave e Valor”?

Use TreeMap para manter a ordem e navegar com firstKey, lastKey, floorKey e ceilingKey. 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 1 de 4.

Quanto tempo leva a aula “TreeMap: Pares Ordenados de Chave e Valor”?

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. TreeMap: Pares Ordenados de Chave e Valor
  2. Submapas e Visões de Intervalos
  3. TreeSet e NavigableSet
  4. Ordenação Personalizada em Coleções Tree
← Voltar para Java Academy