TreeSet: El Maniático del Orden

import java.util.TreeSet;
import java.util.Comparator;

public class OrdenAlfabetico {
    public static void main(String[] args) {
        // 1. Orden Natural (Strings se ordenan alfabéticamente)
        TreeSet<String> invitados = new TreeSet<>();

        invitados.add("Zendaya");
        invitados.add("Brad Pitt");
        invitados.add("Ana de Armas");
        invitados.add("Brad Pitt"); // Duplicado: Se ignora

        // ¡Magia! Salen ordenados sin hacer nada más
        System.out.println("Lista Oficial: " + invitados); 
        // Salida: [Ana de Armas, Brad Pitt, Zendaya]

        // 2. Orden Personalizado (Comparator)
        // Queremos ordenar por longitud del nombre (de corto a largo)
        TreeSet<String> porLongitud = new TreeSet<>(Comparator.comparingInt(String::length));
        porLongitud.addAll(invitados);

        System.out.println("Por longitud: " + porLongitud);
        // Salida: [Zendaya, Brad Pitt, Ana de Armas] (Depende de longitudes)

        // 3. Comprobaciones básicas
        if (invitados.contains("Zendaya")) {
            System.out.println("Zendaya está invitada.");
        }

        System.out.println("Total invitados: " + invitados.size());

        // 4. Clonado
        TreeSet<String> copia = (TreeSet<String>) invitados.clone();
        invitados.clear(); // Borramos el original
        System.out.println("Copia sobrevive: " + copia);
    }
}

import java.util.TreeSet;

public class HighScores {
    public static void main(String[] args) {
        TreeSet<Integer> puntuaciones = new TreeSet<>();
        puntuaciones.add(500);
        puntuaciones.add(100); // Mínimo
        puntuaciones.add(9000); // Máximo
        puntuaciones.add(2500);

        try {
            System.out.println("Puntuación más baja (Noob): " + puntuaciones.first());
            System.out.println("Puntuación más alta (Pro): " + puntuaciones.last());
        } catch (Exception e) {
            System.out.println("Lista vacía");
        }

        // Eliminamos al peor y al mejor
        System.out.println("Eliminando al peor: " + puntuaciones.pollFirst()); // 100
        System.out.println("Eliminando al mejor: " + puntuaciones.pollLast()); // 9000

        System.out.println("Quedan en medio: " + puntuaciones); // [500, 2500]
    }
}

import java.util.TreeSet;

public class BuscadorVuelos {
    public static void main(String[] args) {
        TreeSet<Integer> precios = new TreeSet<>();
        // Precios disponibles
        precios.add(50);
        precios.add(100);
        precios.add(150);
        precios.add(300);
        precios.add(500);

        int miPresupuesto = 150;

        System.out.println("Mi presupuesto exacto: " + miPresupuesto);

        // floor: Quiero gastar 150 o menos (lo más cercano posible)
        System.out.println("Floor (<= 150): " + precios.floor(miPresupuesto)); // 150

        // lower: Quiero gastar MENOS de 150 obligatoriamente
        System.out.println("Lower (< 150): " + precios.lower(miPresupuesto)); // 100

        // ceiling: Si no hay de 150, ¿cuál es el siguiente más barato?
        System.out.println("Ceiling (>= 150): " + precios.ceiling(miPresupuesto)); // 150

        // higher: Quiero algo mejor (más caro) que 150
        System.out.println("Higher (> 150): " + precios.higher(miPresupuesto)); // 300

        // Caso null: Buscamos algo menor que 10 euros
        System.out.println("¿Vuelo por 10€? " + precios.floor(10)); // null
    }
}

import java.util.TreeSet;
import java.util.SortedSet;

public class FiltroRango {
    public static void main(String[] args) {
        TreeSet<Character> alfabeto = new TreeSet<>();
        for(char c = 'a'; c <= 'z'; c++) {
            alfabeto.add(c);
        }

        // 1. subSet: De la 'a' (incluida) a la 'd' (excluida)
        SortedSet<Character> rango = alfabeto.subSet('a', 'd');
        System.out.println("Primeras letras: " + rango); // [a, b, c]

        // 2. tailSet: De la 'x' al final
        System.out.println("Últimas letras: " + alfabeto.tailSet('x')); // [x, y, z]

        // 3. Demostración de vista conectada
        // ¡OJO! Si borro la 'a' del subSet, desaparece del conjunto principal
        rango.remove('a');
        System.out.println("Alfabeto original tras borrar en la vista: " + alfabeto);
        // La 'a' ha desaparecido.
    }
}

import java.util.TreeSet;
import java.util.Iterator;

public class IteracionAvanzada {
    public static void main(String[] args) {
        TreeSet<String> palabras = new TreeSet<>();
        palabras.add("Banana");
        palabras.add("Avión");
        palabras.add("Cereza");

        // Orden natural
        System.out.println("Orden normal: " + palabras); // [Avión, Banana, Cereza]

        // Iterador inverso
        System.out.print("Inverso: ");
        Iterator<String> it = palabras.descendingIterator();
        while(it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        // Salida: Cereza Banana Avión 
        System.out.println();

        // Vista inversa completa
        System.out.println("Set Invertido: " + palabras.descendingSet());

        // Verificamos el comparador
        System.out.println("¿Tiene comparador manual? " + palabras.comparator()); // null

        // Spliterator (Para Streams)
        palabras.spliterator().forEachRemaining(System.out::println);
    }
}