0Pricing
Java Academy · Lección

TreeSet y NavigableSet

Almacene elementos únicos y ordenados, y use floor, ceiling, higher y lower para consultar los elementos vecinos más cercanos.

TreeSet y NavigableSet es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

¿Qué es TreeSet?

TreeSet es un conjunto ordenado respaldado por un árbol rojo-negro. Almacena elementos únicos en orden natural ascendente (o según el comparador proporcionado). Todas las operaciones tienen un coste 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, que proporciona métodos de navegación para encontrar los elementos más cercanos:

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

Acceda a los elementos de los extremos o elimínelos:

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

Extraiga vistas 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]

Iteración descendente

Utilice descendingIterator() o descendingSet() para obtener el orden inverso:

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

Orden personalizado mediante Comparator

Pase un Comparator para ordenar según un criterio no natural; por ejemplo, colocando primero las cadenas más largas:

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: nombres de usuario únicos y ordenados

Almacene los nombres de usuario en un TreeSet para eliminar duplicados automáticamente y mantener el orden alfabético:

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: recuento en un rango

Cuente los elementos de un rango mediante 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 frente a HashSet y LinkedHashSet

Elija según sus necesidades:

  • HashSet: operaciones O(1), sin orden
  • LinkedHashSet: operaciones O(1), ordenado por inserción
  • TreeSet: operaciones O(log n), ordenado y con métodos de navegación

TreeSet requiere que los elementos implementen Comparable o que se proporcione un Comparator.

Elementos null

TreeSet NO permite elementos null cuando se utiliza el orden natural: se lanza una NullPointerException porque null no se puede comparar. Funcionaría un comparador personalizado que gestionara null explícitamente.

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

Seguridad de subprocesos

TreeSet NO es seguro para subprocesos. Sincronice externamente con Collections.synchronizedSortedSet() o utilice ConcurrentSkipListSet, que es ordenado y seguro para subprocesos.

Comprobación rápida

Un TreeSet<Integer> contiene {10, 20, 30, 40, 50}. ¿Qué devuelve set.ceiling(35)?

Repaso: TreeSet y NavigableSet

Aspectos clave:

  • TreeSet almacena elementos únicos y ordenados (O(log n))
  • Implementa NavigableSet: floor, ceiling, lower, higher, first y last
  • headSet, tailSet y subSet devuelven vistas de rangos respaldadas
  • Utilice descendingSet()/descendingIterator() para el orden inverso
  • No es seguro para subprocesos; utilice ConcurrentSkipListSet para la concurrencia

Preguntas frecuentes

¿La lección «TreeSet y NavigableSet» es gratis?

Sí — el texto completo de «TreeSet y NavigableSet» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «TreeSet y NavigableSet»?

Almacene elementos únicos y ordenados, y use floor, ceiling, higher y lower para consultar los elementos vecinos más cercanos. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «TreeSet y NavigableSet»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. TreeMap: pares ordenados de clave y valor
  2. Submapas y vistas de rangos
  3. TreeSet y NavigableSet
  4. Orden personalizado en colecciones de árbol
← Volver a Java Academy