0Pricing
Java Academy · Aula

TreeSet e NavigableSet

Armazene elementos exclusivos e ordenados e use floor, ceiling, higher e lower para consultas de vizinhança.

TreeSet e NavigableSet é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 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 TreeSet?

TreeSet é um conjunto ordenado baseado em uma árvore rubro-negra. Ele armazena elementos únicos em ordem natural crescente (ou na ordem de um comparador fornecido). Todas as operações são O(log n).

import java.util.TreeSet;

TreeSet<String> names = new TreeSet<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
names.add("Alice"); // duplicate ignored

for (String s : names) System.out.print(s + " ");
// Alice Bob Charlie

Métodos de NavigableSet: floor, ceiling, lower, higher

TreeSet implementa NavigableSet, fornecendo métodos de navegação para encontrar os elementos mais próximos:

TreeSet<Integer> set = new TreeSet<>();
for (int i = 10; i <= 50; i += 10) set.add(i);
// {10, 20, 30, 40, 50}

System.out.println(set.floor(25));   // 20 (greatest ≤ 25)
System.out.println(set.ceiling(25)); // 30 (smallest ≥ 25)
System.out.println(set.lower(30));   // 20 (strictly less)
System.out.println(set.higher(30));  // 40 (strictly greater)

first, last, pollFirst, pollLast

Acesse ou remova os elementos dos limites:

TreeSet<String> ts = new TreeSet<>(Set.of("cherry","apple","banana","date"));

System.out.println(ts.first());       // apple
System.out.println(ts.last());        // date
System.out.println(ts.pollFirst());   // apple (removed)
System.out.println(ts.pollLast());    // date (removed)
System.out.println(ts);              // [banana, cherry]

headSet, tailSet, subSet

Extraia visualizações de subconjuntos ordenados:

TreeSet<Integer> set = new TreeSet<>(Set.of(1,2,3,4,5,6,7,8,9,10));

System.out.println(set.headSet(5));      // [1, 2, 3, 4]
System.out.println(set.tailSet(7));      // [7, 8, 9, 10]
System.out.println(set.subSet(3, 7));    // [3, 4, 5, 6]

// Inclusive upper bound:
System.out.println(set.subSet(3, true, 7, true)); // [3,4,5,6,7]

Iteração descendente

Use descendingIterator() ou descendingSet() para obter a ordem inversa:

TreeSet<Integer> ts = new TreeSet<>(Set.of(1,3,5,7,9));

// Descending iterator
var it = ts.descendingIterator();
while (it.hasNext()) System.out.print(it.next() + " ");
// 9 7 5 3 1

Ordenação personalizada com Comparator

Passe um Comparator para ordenar segundo uma regra não natural — por exemplo, as strings mais longas primeiro:

TreeSet<String> byLength = new TreeSet<>(
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder())
);
byLength.add("Hi");
byLength.add("Hello");
byLength.add("Hey");
byLength.add("Java");

for (String s : byLength) System.out.print(s + " ");
// Hi Hey Java Hello

Caso de uso: nomes de usuário únicos e ordenados

Armazene nomes de usuário em uma TreeSet para remover duplicatas automaticamente e manter a ordem alfabética:

TreeSet<String> users = new TreeSet<>();
users.add("alice");
users.add("bob");
users.add("alice"); // ignored
users.add("carol");

System.out.println(users.first()); // alice
System.out.println(users);         // [alice, bob, carol]

Caso de uso: contagem em um intervalo

Conte os elementos em um intervalo usando subSet:

TreeSet<Integer> scores = new TreeSet<>();
for (int s : new int[]{45,62,78,55,90,88,34,71}) scores.add(s);

// Scores between 60 and 89 (inclusive)
int count = scores.subSet(60, true, 89, true).size();
System.out.println("Students in B range: " + count); // 3 (62, 78, 88... wait: 62,78,71,88=4)
// Actually: 62,71,78,88 = 4

TreeSet versus HashSet versus LinkedHashSet

Escolha de acordo com as necessidades:

  • HashSet: operações O(1), sem ordenação
  • LinkedHashSet: operações O(1), ordenado pela inserção
  • TreeSet: operações O(log n), ordem ordenada e métodos de navegação

TreeSet exige que os elementos implementem Comparable ou um Comparator.

Elementos nulos

TreeSet NÃO permite elementos null ao usar a ordenação natural — uma NullPointerException é lançada porque null não pode ser comparado. Um comparador personalizado que trate explicitamente null funcionaria.

TreeSet<String> ts = new TreeSet<>();
try {
    ts.add(null); // throws NullPointerException
} catch (NullPointerException e) {
    System.out.println("Cannot add null: " + e);
}

Segurança em relação a threads

TreeSet NÃO é segura para uso com várias threads. Faça a sincronização externamente com Collections.synchronizedSortedSet() ou use ConcurrentSkipListSet, que é ordenada e segura para uso com várias threads.

Verificação rápida

Uma TreeSet<Integer> contém {10, 20, 30, 40, 50}. O que set.ceiling(35) retorna?

Recapitulação: TreeSet e NavigableSet

Principais conclusões:

  • TreeSet armazena elementos únicos e ordenados (O(log n))
  • Implementa NavigableSet: floor, ceiling, lower, higher, first, last
  • headSet, tailSet, subSet retornam visualizações de intervalos apoiadas pelo conjunto
  • Use descendingSet()/descendingIterator() para obter a ordem inversa
  • Não é segura para uso com várias threads — use ConcurrentSkipListSet para acesso simultâneo

Perguntas Frequentes

A aula “TreeSet e NavigableSet” é grátis?

Sim — o texto completo de “TreeSet e NavigableSet” é 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 “TreeSet e NavigableSet”?

Armazene elementos exclusivos e ordenados e use floor, ceiling, higher e lower para consultas de vizinhança. 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 3 de 4.

Quanto tempo leva a aula “TreeSet e NavigableSet”?

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