TreeMap

🧠 O que é TreeMap?

TreeMap é uma implementação da interface NavigableMap baseada em uma árvore rubro-negra.
Ele mantém as chaves ordenadas de acordo com a ordem natural (Comparable) ou por meio de um Comparator fornecido.

🧪 Características principais

• Ordena as chaves automaticamente (ordem natural ou por Comparator)
• Não permite null como chave, mas permite null como valor
• Métodos especiais de navegação como lowerKey, higherKey, ceilingKey, floorKey
• Complexidade de tempo para operações: O(log n)

📘 Principais métodos

✅ Exemplo prático com comentários

import java.util.*;
import static java.lang.System.out;
public class ExemploTreeMap {
  public static void main(String[] args) {
    TreeMap<Integer, String> mapa = new TreeMap<>();

    mapa.put(3, "Três");
    mapa.put(1, "Um");
    mapa.put(4, "Quatro");
    mapa.put(2, "Dois");

    out.println(mapa); 
// {1=Um, 2=Dois, 3=Três, 4=Quatro}

    out.println(mapa.firstKey()); // 1
    out.println(mapa.lastKey()); // 4
    out.println(mapa.lowerKey(3)); // 2
    out.println(mapa.higherKey(3)); // 4
    out.println(mapa.ceilingKey(3)); // 3
    out.println(mapa.floorKey(3)); // 3

    out.println(mapa.descendingMap());
 // {4=Quatro, 3=Três, 2=Dois, 1=Um}

  }
}

🔑 keySet()

Retorna: um Set<K> contendo somente as chaves do mapa.

Você pode usar esse método quando precisa iterar ou verificar apenas as chaves do Map.

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

for (Integer chave : map.keySet()) {
  System.out.println(chave);
}

🖨️ Saída:

1
2

📦 values()

Retorna: uma Collection<V> com todos os valores do mapa.

Use quando você precisa trabalhar só com os valores, sem se importar com as chaves.

for (String valor : map.values()) {
  System.out.println(valor);
}

🖨️ Saída:

A
B

🔑📦 entrySet()

Retorna: um Set<Map.Entry<K, V>> — ou seja, um conjunto de objetos contendo par chave-valor.

É o mais completo: permite acessar chave e valor ao mesmo tempo, ideal para iteração geral.

for (Map.Entry<Integer, String> entrada : map.entrySet()) {
  System.out.println("Chave: " + entrada.getKey() + ", Valor: " + entrada.getValue());
}

🖨️ Saída:

Chave: 1, Valor: A
Chave: 2, Valor: B

🆚 Comparação rápida:

🧠 Dica de prova

• Se a questão pede apenas os valores, escolha values().
• Se pede apenas as chaves, use keySet().
• Se pede chave e valor, ou modificação, use entrySet().

❌ Erro comum:

Tentar modificar um valor com keySet() ou values():

for (String valor : map.values()) {
// ❌ Isso não altera o mapa!
  valor = "novo"; 
}

✅ Para alterar o valor corretamente:

for (Map.Entry<Integer, String> e : map.entrySet()) {
  if (e.getKey() == 2) {
    e.setValue("Novo Valor");
  }
}

❌ Exemplos incorretos

TreeMap<String, String> mapa = new TreeMap<>();
mapa.put(null, "valor"); 
// ❌ NullPointerException

Comentário: TreeMap não permite null como chave pois precisa comparar as chaves com compareTo.

TreeMap<Object, String> mapa = new TreeMap<>();
mapa.put("a", "valor");
mapa.put(1, "outro"); // ❌
// ❌ ClassCastException em tempo de execução

Comentário: as chaves precisam ser mutuamente comparáveis, ou seja, a mesma classe ou classes compatíveis com compareTo.

🪄 Dicas e pegadinhas da prova

1. TreeMap não permite null como chave.
2. Os métodos de navegação (lowerKey, higherKey, etc.) são muito cobrados.
3. O comportamento de TreeMap muda quando usamos um Comparator personalizado.
4. A ordenação é pela chave, não pelo valor.
5. Se duas chaves forem consideradas iguais pelo Comparator, apenas a última prevalece.

🎯 Simulado

TreeMap<Integer, String> map = new TreeMap<>();
map.put(10, "A");
map.put(5, "B");
map.put(15, "C");
System.out.println(map.firstKey());

a) 5
b) 10
c) 15
d) A

a) ceilingKey
b) floorKey
c) lowerKey
d) higherKey

a) Nada
b) Armazena normalmente
c) Lança NullPointerException
d) Substitui a chave anterior

TreeMap<Integer, String> map = new TreeMap<>();
map.put(2, "B");
map.put(1, "A");
map.put(3, "C");
System.out.println(map.get(2));

a) null
b) A
c) B
d) 2

a) map.reverse()
b) map.orderByDesc()
c) map.descendingMap()
d) map.sortDesc()

a) Sim
b) Não
c) Sim, se ambos implementarem Serializable
d) Sim, se ambos implementarem Comparable

TreeMap<Integer, String> map = new TreeMap<>();
System.out.println(map.firstKey());

a) null
b) lança exceção
c) 0
d) compila e não imprime nada

a) É baseada em LinkedList
b) Permite chaves duplicadas
c) Ordena os elementos por valor
d) É baseada em árvore balanceada

a) 3
b) 5
c) 7
d) null

a) O(1)
b) O(n)
c) O(log n)
d) O(n log n)

🧾 Resumo

• TreeMap mantém chaves ordenadas.
• Não permite null como chave.
• Usa Comparable por padrão, mas pode aceitar Comparator.
• Ideal para buscas ordenadas e intervalares.
• Muito útil quando a ordem das chaves importa.
• Métodos como lowerKey, ceilingKey, descendingMap são favoritos na prova.