PULSOFT

package linkedhashset;

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;

public class Ejercicio1 {

    public static void main(String[] args) {
        MenuEjercicio1 menu = new MenuEjercicio1();  // Se crea una instancia de la clase MenuEjercicio1
        menu.mostrarMenu();  // Se llama al método mostrarMenu() para iniciar la interacción con el usuario
    }

}

class MenuEjercicio1 {

    int menu = 0;  // Variable para almacenar la opción seleccionada por el usuario
    LinkedHashSet<String> listaNombres = new LinkedHashSet<String>();  // Se crea un LinkedHashSet para almacenar los nombres
    Scanner entrada = new Scanner(System.in);  // Scanner para recibir entradas del usuario

    public void mostrarMenu() {
        do {
            // Mostrar el menú de opciones al usuario
            System.out.println("Menu nombres");
            System.out.println("1.Agregar nombres");
            System.out.println("2.Mostrar nombres");
            System.out.println("3.Eliminar nombre");
            System.out.println("4.Mostrar cantidad nombres unicos");
            System.out.println("5.Comprobar un nombre");
            System.out.println("6.Salir");
            System.out.println("Escoge opcion:");

            try {
                // Leer la opción del usuario
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu);  // Gestionar la opción seleccionada
            } catch (NumberFormatException e) {
                // Manejar la excepción si el usuario introduce una opción no válida
                System.err.println("Formato de menu no valido, introducelo de nuevo");
            }

        } while (menu != 6);  // El menú se repite hasta que el usuario seleccione la opción de salir
    }

    private void gestionarMenu(int menu) {
        // Estructura de switch moderna para manejar las opciones del menú
        switch (menu) {
            case 1 -> agregarNombre();  // Agregar un nombre
            case 2 -> mostrarLista();  // Mostrar todos los nombres
            case 3 -> eliminarNombre();  // Eliminar un nombre específico
            case 4 -> System.out.println("La lista contiene " + listaNombres.size() + " nombre unicos");  // Mostrar el número de nombres únicos
            case 5 -> comprobarNombre();  // Comprobar si un nombre está en la lista
            case 6 -> {
                // Opción para salir del programa
                System.out.println("Saliendo del programa...");
                entrada.close();  // Cerrar el Scanner al salir
                break;
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");  // Opción no válida
        }
    }

    // Método para capitalizar el nombre (poner la primera letra en mayúscula y el resto en minúscula)
    private String ponerMayuscula(String nombre) {
        return nombre.substring(0, 1).toUpperCase() + nombre.substring(1).toLowerCase();
    }

    // Método para agregar un nombre a la lista
    private void agregarNombre() {
        String nombre = "";

        while (true) {
            System.out.println("Introduce un nombre");
            nombre = entrada.nextLine();

            // Validación para evitar que el nombre esté vacío
            if (nombre.equals("")) {
                System.out.println("El nombre no puede quedar en blanco, introducelo de nuevo");
            } else {
                break;
            }
        }

        nombre = ponerMayuscula(nombre);  // Formatear el nombre

        // Intentar agregar el nombre al LinkedHashSet
        if (!listaNombres.add(nombre)) {
            System.out.println("El nombre esta duplicado no se agregara");
        } else {
            System.out.println("Nombre agregado correctamente");
        }
    }

    // Método para comprobar si un nombre ya está en la lista
    private void comprobarNombre() {
        String nombre = "";

        while (true) {
            System.out.println("Introduce un nombre");
            nombre = entrada.nextLine();

            // Validación para evitar que el nombre esté vacío
            if (nombre.equals("")) {
                System.out.println("El nombre no puede quedar en blanco, introducelo de nuevo");
            } else {
                break;
            }
        }

        nombre = ponerMayuscula(nombre);  // Formatear el nombre

        // Comprobar si el nombre está en la lista
        if (!listaNombres.contains(nombre)) {
            System.out.println("El nombre no esta en la lista");
        } else {
            System.out.println("El nombre ya esta en la lista");
        }
    }

    // Método para mostrar todos los nombres en el orden de inserción
    private void mostrarLista() {
        if (listaNombres.isEmpty()) {
            System.out.println("La lista aun esta vacia");
        } else {
            System.out.println("Lista completa de nombres en el orden que se agregaron");
            int index = 1;
            for (String nombre : listaNombres) {
                System.out.println(index + "." + nombre);  // Mostrar el índice junto al nombre
                index++;
            }
        }
    }

    // Método para eliminar un nombre de la lista
    private void eliminarNombre() {
        if (listaNombres.isEmpty()) {
            System.out.println("La lista aun esta vacia");
        } else {
            mostrarLista();  // Mostrar los nombres antes de eliminar uno

            int index = 0;

            // Bucle para obtener un índice válido del usuario
            while (true) {
                try {
                    System.out.println("Introduce el indice del nombre a borrar");
                    index = Integer.parseInt(entrada.nextLine());
                } catch (NumberFormatException e) {
                    System.err.println("Opcion de index de la lista no valida, introducela de nuevo");
                }

                if (index < 1 || index > listaNombres.size()) {
                    System.out.println("El indice tiene que estar comprendido entre 1 y " + listaNombres.size());
                } else {
                    break;
                }
            }

            char respuesta = ' ';

            // Confirmación para borrar el nombre
            while (true) {
                System.out.println("¿Seguro que quieres borrar el nombre? (s)o(n)");
                respuesta = entrada.nextLine().toLowerCase().charAt(0);

                if (respuesta != 's' && respuesta != 'n') {
                    System.out.println("La respuesta tiene que ser (s)o(n), introducela de nuevo");
                } else {
                    break;
                }
            }

            if (respuesta == 'n') {
                System.out.println("Operacion de borrado abortada");
            } else {
                Iterator<String> it = listaNombres.iterator();

                int indice = 1;
                while (it.hasNext()) {
                    it.next();
                    if (indice == index) {
                        it.remove();  // Eliminar el nombre si el índice coincide
                        System.out.println("Nombre borrado con exito");
                        break;
                    }
                    indice++;
                }
            }
        }
    }
}

package linkedhashset;

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;

public class Ejercicio2 {

    public static void main(String[] args) {
        // Crear una instancia del menú y mostrar el menú
        MenuEjercicio2 menu = new MenuEjercicio2();
        menu.MostrarMenu();
    }

}

class MenuEjercicio2 {

    // LinkedHashSet para almacenar los números enteros
    LinkedHashSet<Integer> listaNumeros = new LinkedHashSet<Integer>();
    Scanner entrada = new Scanner(System.in);
    int menu = 0;

    public void MostrarMenu() {

        do {
            // Mostrar las opciones del menú
            System.out.println("Menu numeros");
            System.out.println("1.Añadir numero");
            System.out.println("2.Mostrar numeros en orden de agregados");
            System.out.println("3.Eliminar un numero especifico");
            System.out.println("4.Mostrar cantidad de numeros");
            System.out.println("5.Comprobar si un numero existe en la lista");
            System.out.println("6.Mostrar el numero mayor y menor");
            System.out.println("7.Salir del programa");
            System.out.println("Escoge opcion:");

            try {
                // Leer la opción seleccionada
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu); // Gestionar la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato de menu invalido, introducelo de nuevo");
            }
        } while (menu != 7); // El ciclo continúa hasta que el usuario elige salir
    }

    // Método para gestionar el menú según la opción seleccionada
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> agregarNumero(); // Añadir número
            case 2 -> mostrarLista(); // Mostrar la lista de números
            case 3 -> eliminarNumero(); // Eliminar un número específico
            case 4 -> System.out.println("En la lista hay un total de " + listaNumeros.size() + " numeros"); // Mostrar cantidad
            case 5 -> comprobarExiste(); // Comprobar si un número está en la lista
            case 6 -> mayorMenor(); // Mostrar el número mayor y menor
            case 7 -> {
                System.out.println("Saliendo del programa...");
                entrada.close(); // Cerrar el scanner y salir
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
        }
    }

    // Método para agregar un número a la lista
    private void agregarNumero() {
        int num = 0;

        while (true) {
            try {
                System.out.println("Introduce un numero entero:");
                num = Integer.parseInt(entrada.nextLine());
                break;
            } catch (NumberFormatException e) {
                System.err.println("Formato de numero entero no valido, introducelo de nuevo");
            }
        }

        // Intentar añadir el número al LinkedHashSet, evitando duplicados
        if (!listaNumeros.add(num)) {
            System.out.println("El numero ya estaba en la lista, no se agregara");
        } else {
            System.out.println("Numero agregado correctamente");
        }
    }

    // Método para mostrar los números en el orden en que fueron agregados
    private void mostrarLista() {
        if (listaNumeros.isEmpty()) {
            System.out.println("La lista aun esta vacia");
        } else {
            System.out.println("Lista de numeros completa por orden de agregados");
            for (Integer num : listaNumeros) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }

    // Método para comprobar si un número está en la lista
    private void comprobarExiste() {
        if (listaNumeros.isEmpty()) {
            System.out.println("La lista aun esta vacia");
        } else {
            int num = 0;

            while (true) {
                try {
                    System.out.println("Introduce un numero entero:");
                    num = Integer.parseInt(entrada.nextLine());
                    break;
                } catch (NumberFormatException e) {
                    System.err.println("Formato de numero entero no valido, introducelo de nuevo");
                }
            }

            // Comprobar si el número está en la lista
            if (listaNumeros.contains(num)) {
                System.out.println("El numero " + num + " se encuentra en la lista");
            } else {
                System.out.println("El numero " + num + " no se encuentra en la lista");
            }
        }
    }

    // Método para mostrar el número mayor y menor en la lista
    private void mayorMenor() {
        if (listaNumeros.isEmpty()) {
            System.out.println("La lista aun esta vacia");
        } else {
            // Usar streams para encontrar el número menor y mayor
            System.out.println("El numero menor de la lista es " + listaNumeros.stream().min(Integer::compareTo));
            System.out.println("El numero max de la lista es " + listaNumeros.stream().max(Integer::compareTo));
        }
    }

    // Método para eliminar un número específico de la lista
    private void eliminarNumero() {
        if (listaNumeros.isEmpty()) {
            System.out.println("La lista aun esta vacia");
        } else {
            int num = 0;

            while (true) {
                try {
                    System.out.println("Introduce un numero entero:");
                    num = Integer.parseInt(entrada.nextLine());
                    break;
                } catch (NumberFormatException e) {
                    System.err.println("Formato de numero entero no valido, introducelo de nuevo");
                }
            }

            boolean encontrado = false;
            Iterator<Integer> it = listaNumeros.iterator();

            // Recorrer la lista y buscar el número a eliminar
            while (it.hasNext()) {
                int numero = it.next();
                if (numero == num) {
                    char respuesta = ' ';

                    // Confirmar si el usuario quiere borrar el número
                    while (true) {
                        System.out.println("¿Seguro que quieres borrar el numero " + num + "? (s)o(n)");
                        respuesta = entrada.nextLine().toLowerCase().charAt(0);

                        if (respuesta != 's' && respuesta != 'n') {
                            System.out.println("La respuesta tiene que ser (s)o(n), introducela de nuevo");
                        } else {
                            break;
                        }
                    }

                    if (respuesta == 's') {
                        it.remove(); // Eliminar el número si la respuesta es 's'
                        System.out.println("Numero " + num + " eliminado de la lista con exito");
                        encontrado = true;
                    } else {
                        System.out.println("Operacion borrar numero " + num + " abortada");
                        encontrado = true;
                    }
                }
            }

            if (!encontrado) {
                System.out.println("El numero no se encontraba en la lista");
            }
        }
    }
}

package linkedhashset;

import java.time.LocalDate;
import java.time.Year;
import java.time.format.DateTimeFormatter;
import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Scanner;

public class Ejercicio3 {

    public static void main(String[] args) {
        // Instancia la clase del menú e inicia la interacción con el usuario
        MenuEjercicio3 menu = new MenuEjercicio3();
        menu.mostrarMenu();
    }
}

// La clase Fecha representa un objeto de tipo fecha con formato europeo (dd/MM/yyyy)
class Fecha implements Comparable<Fecha> {
    private LocalDate fecha;

    // Constructor que inicializa la fecha con un objeto LocalDate
    public Fecha(LocalDate fecha) {
        this.fecha = fecha;
    }

    // Métodos de acceso para obtener y establecer la fecha
    public LocalDate getFecha() {
        return fecha;
    }

    public void setFecha(LocalDate fecha) {
        this.fecha = fecha;
    }

    // Implementa hashCode para identificar fechas únicas en LinkedHashSet
    @Override
    public int hashCode() {
        return Objects.hash(fecha); // Usa la fecha como clave para el hash
    }

    // Implementa equals para comparar dos objetos Fecha
    @Override
    public boolean equals(Object obj) {
        // Verifica si el objeto comparado es el mismo o si es nulo
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        // Compara las fechas dentro de los dos objetos
        Fecha other = (Fecha) obj;
        return Objects.equals(fecha, other.fecha);
    }

    // Permite comparar fechas para ordenar de menor a mayor
    @Override
    public int compareTo(Fecha otraFecha) {
        return this.fecha.compareTo(otraFecha.getFecha());
    }

    // Retorna la fecha en formato dd/MM/yyyy para presentación
    @Override
    public String toString() {
        DateTimeFormatter formatoEuropeo = DateTimeFormatter.ofPattern("dd/MM/yyyy");
        return fecha.format(formatoEuropeo);
    }
}

// Clase que maneja la lógica del menú para manipular el conjunto de fechas
class MenuEjercicio3 {

    // Conjunto de fechas que asegura unicidad y orden de inserción
    private LinkedHashSet<Fecha> fechas = new LinkedHashSet<>();
    private Scanner entrada = new Scanner(System.in);

    // Método para mostrar el menú principal y gestionar las opciones
    public void mostrarMenu() {
        int menu = 0; // Variable para almacenar la selección del usuario
        do {
            // Despliega el menú de opciones para el usuario
            System.out.println("\n--- Menu de Fechas ---");
            System.out.println("1. Agregar fecha");
            System.out.println("2. Eliminar fecha");
            System.out.println("3. Mostrar total de fechas");
            System.out.println("4. Verificar si una fecha existe");
            System.out.println("5. Mostrar fecha más reciente y más antigua");
            System.out.println("6. Salir");
            System.out.print("Selecciona una opción: ");
            try {
                menu = Integer.parseInt(entrada.nextLine()); // Captura y convierte la entrada
                gestionarMenu(menu); // Llama al método para manejar cada opción
            } catch (NumberFormatException e) {
                System.err.println("Formato no válido. Inténtalo de nuevo.");
            }
        } while (menu != 6); // Repite hasta que el usuario elija salir
    }

    // Ejecuta la acción correspondiente según la opción seleccionada en el menú
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> agregarFecha(); // Agregar una nueva fecha al conjunto
            case 2 -> eliminarFecha(); // Eliminar una fecha específica
            case 3 -> mostrarTotal(); // Mostrar el total de fechas guardadas
            case 4 -> verificarFecha(); // Verificar si una fecha específica ya existe
            case 5 -> maxMinFecha(); // Mostrar la fecha más reciente y la más antigua
            case 6 -> { // Salir del programa y cerrar el scanner
                System.out.println("Saliendo del programa...");
                entrada.close();
            }
            default -> System.out.println("Opción no válida.");
        }
    }

    // Método para agregar una fecha ingresada por el usuario, validando que sea única
    private void agregarFecha() {
        // Recopila año, mes y día mediante métodos específicos
        int anio = agregarAnio();
        int mes = agregarMes();
        int dia = agregarDia(mes, anio);

        // Crea un objeto Fecha y verifica si ya está en el conjunto
        LocalDate fechaAgregar = LocalDate.of(anio, mes, dia);
        Fecha fecha = new Fecha(fechaAgregar);
        if (!fechas.add(fecha)) { // Intenta agregar la fecha, y si ya existe no la añade
            System.out.println("La fecha " + fecha + " ya está en la lista.");
        } else {
            System.out.println("Fecha agregada correctamente: " + fecha);
        }
    }

    // Método para eliminar una fecha específica ingresada por el usuario
    private void eliminarFecha() {
        // Solicita y valida la fecha a eliminar
        int anio = agregarAnio();
        int mes = agregarMes();
        int dia = agregarDia(mes, anio);

        // Crea el objeto Fecha y lo busca en el conjunto para eliminarlo
        LocalDate fechaEliminar = LocalDate.of(anio, mes, dia);
        Fecha fecha = new Fecha(fechaEliminar);
        if (fechas.remove(fecha)) {
            System.out.println("Fecha eliminada correctamente: " + fecha);
        } else {
            System.out.println("La fecha " + fecha + " no se encuentra en la lista.");
        }
    }

    // Muestra el número total de fechas almacenadas en el conjunto
    private void mostrarTotal() {
        System.out.println("Total de fechas: " + fechas.size());
    }

    // Verifica si una fecha específica está en el conjunto
    private void verificarFecha() {
        // Solicita y valida la fecha a verificar
        int anio = agregarAnio();
        int mes = agregarMes();
        int dia = agregarDia(mes, anio);

        // Crea el objeto Fecha y verifica si existe en el conjunto
        LocalDate fechaVerificar = LocalDate.of(anio, mes, dia);
        Fecha fecha = new Fecha(fechaVerificar);
        if (fechas.contains(fecha)) {
            System.out.println("La fecha " + fecha + " está en la lista.");
        } else {
            System.out.println("La fecha " + fecha + " no está en la lista.");
        }
    }

    // Encuentra y muestra la fecha más antigua y la más reciente en el conjunto
    private void maxMinFecha() {
        // Encuentra la fecha más antigua (mínima) si existen fechas
        fechas.stream().min(Fecha::compareTo)
               .ifPresentOrElse(
                   fechaMin -> System.out.println("Fecha más antigua: " + fechaMin),
                   () -> System.out.println("No hay fechas en la lista.")
               );

        // Encuentra la fecha más reciente (máxima) si existen fechas
        fechas.stream().max(Fecha::compareTo)
               .ifPresentOrElse(
                   fechaMax -> System.out.println("Fecha más reciente: " + fechaMax),
                   () -> System.out.println("No hay fechas en la lista.")
               );
    }

    // Método para solicitar el año, validando que sea igual o posterior al año actual
    private int agregarAnio() {
        while (true) {
            try {
                System.out.print("Introduce el año: ");
                int anio = Integer.parseInt(entrada.nextLine());
                if (anio >= LocalDate.now().getYear()) return anio; // Valida año actual o futuro
                System.out.println("El año debe ser igual o posterior al año actual.");
            } catch (NumberFormatException e) {
                System.err.println("Formato no válido. Inténtalo de nuevo.");
            }
        }
    }

    // Método para solicitar el mes, asegurando que esté entre 1 y 12
    private int agregarMes() {
        while (true) {
            try {
                System.out.print("Introduce el mes (1-12): ");
                int mes = Integer.parseInt(entrada.nextLine());
                if (mes >= 1 && mes <= 12) return mes; // Valida rango de mes válido
                System.out.println("El mes debe estar entre 1 y 12.");
            } catch (NumberFormatException e) {
                System.err.println("Formato no válido. Inténtalo de nuevo.");
            }
        }
    }

    // Método para solicitar el día, ajustándolo al mes y año proporcionados
    private int agregarDia(int mes, int anio) {
        // Determina el número máximo de días según el mes y el año (considera bisiestos)
        int maxDia = switch (mes) {
            case 2 -> Year.isLeap(anio) ? 29 : 28; // Febrero en año bisiesto
            case 4, 6, 9, 11 -> 30; // Meses de 30 días
            default -> 31; // Meses de 31 días
        };

        // Solicita el día al usuario y verifica que sea válido para el mes y año dados
        while (true) {
            try {
                System.out.print("Introduce el día: ");
                int dia = Integer.parseInt(entrada.nextLine());
                if (dia >= 1 && dia <= maxDia) return dia; // Verifica rango de día válido
                System.out.println("El día debe estar entre 1 y " + maxDia + " para el mes " + mes + ".");
            } catch (NumberFormatException e) {
                System.err.println("Formato no válido. Inténtalo de nuevo.");
            }
        }
    }
}

package linkedhashset;

import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Scanner;

public class Ejercicio4 {

    public static void main(String[] args) {
        // Instancia y muestra el menú de la biblioteca
        MenuEjercicio4 menu = new MenuEjercicio4();
        menu.mostrarMenu();
    }
}

// Clase Libro que implementa Comparable para permitir la comparación de años de publicación
class Libro implements Comparable<Libro> {
    private String titulo;
    private String autor;
    private int anio;

    // Constructor para inicializar un libro con título, autor y año de publicación
    public Libro(String titulo, String autor, int anio) {
        this.titulo = titulo;
        this.autor = autor;
        this.anio = anio;
    }

    // Métodos de acceso para los atributos de la clase
    public String getTitulo() {
        return titulo;
    }

    public String getAutor() {
        return autor;
    }

    public int getAnio() {
        return anio;
    }

    // Sobrescribe hashCode para identificar libros únicos en LinkedHashSet, usando título y autor
    @Override
    public int hashCode() {
        return Objects.hash(titulo, autor);
    }

    // Sobrescribe equals para comparar libros por título y autor
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Libro other = (Libro) obj;
        return Objects.equals(titulo, other.titulo) && Objects.equals(autor, other.autor);
    }

    // Método toString para mostrar la información de un libro
    @Override
    public String toString() {
        return "\nTitulo --> " + titulo + "\nAutor --> " + autor + "\nAño --> " + anio;
    }

    // Implementación de compareTo para ordenar libros por año de publicación
    @Override
    public int compareTo(Libro other) {
        return Integer.compare(this.anio, other.anio);
    }
}

// Clase para gestionar el menú de la biblioteca y las operaciones con los libros
class MenuEjercicio4 {
    private LinkedHashSet<Libro> listaLibros = new LinkedHashSet<>();
    private Scanner entrada = new Scanner(System.in);
    private int menu = 0;

    // Método para mostrar el menú principal y manejar las opciones seleccionadas por el usuario
    public void mostrarMenu() {
        do {
            System.out.println("Menu biblioteca");
            System.out.println("1. Añadir libro");
            System.out.println("2. Eliminar libro");
            System.out.println("3. Mostrar total de libros");
            System.out.println("4. Buscar un libro");
            System.out.println("5. Listar libros");
            System.out.println("6. Mostrar el libro más reciente y el más antiguo");
            System.out.println("7. Salir del programa");
            System.out.print("Escoge opción: ");
            
            try {
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
        } while (menu != 7);
    }

    // Método para solicitar al usuario un campo de texto no vacío
    private String campoTexto(String campo) {
        while (true) {
            System.out.print("Introduce el " + campo + " del libro: ");
            String dato = entrada.nextLine().trim();
            if (!dato.isEmpty()) return dato;
            System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo.");
        }
    }

    // Método para solicitar y validar el año de publicación del libro
    private int campoAnio() {
        while (true) {
            System.out.print("Introduce el año del libro: ");
            try {
                int dato = Integer.parseInt(entrada.nextLine());
                if (dato >= -2000) return dato;
                System.out.println("El año no puede ser inferior a -2000.");
            } catch (NumberFormatException e) {
                System.err.println("Formato de año inválido, introdúcelo de nuevo.");
            }
        }
    }

    // Método para agregar un libro a la colección, verificando si ya existe
    private void agregarLibro() {
        String titulo = campoTexto("título");
        String autor = campoTexto("autor");
        int anio = campoAnio();

        Libro libro = new Libro(titulo, autor, anio);
        if (!listaLibros.add(libro)) {
            System.out.println("El libro ya está registrado en la biblioteca.");
        } else {
            System.out.println("Libro agregado correctamente.");
        }
    }

    // Método para eliminar un libro de la colección usando título y autor
    private void eliminarLibro() {
        if (listaLibros.isEmpty()) {
            System.out.println("La lista de libros está vacía.");
            return;
        }

        String titulo = campoTexto("título");
        String autor = campoTexto("autor");
        Libro libroABorrar = new Libro(titulo, autor, 0); // El año no importa para la eliminación

        if (listaLibros.remove(libroABorrar)) {
            System.out.println("Libro eliminado con éxito.");
        } else {
            System.out.println("El libro no se encuentra en la biblioteca.");
        }
    }

    // Método para mostrar la cantidad total de libros en la colección
    private void cantidadLibros() {
        System.out.println("Actualmente la biblioteca dispone de " + listaLibros.size() + " libro/s.");
    }

    // Método para buscar un libro en la colección usando título y autor
    private void buscarLibro() {
        if (listaLibros.isEmpty()) {
            System.out.println("La biblioteca está vacía.");
            return;
        }

        String titulo = campoTexto("título");
        String autor = campoTexto("autor");
        Libro libroBuscado = new Libro(titulo, autor, 0); // El año no importa para la búsqueda

        if (listaLibros.contains(libroBuscado)) {
            for (Libro libro : listaLibros) {
                if (libro.equals(libroBuscado)) {
                    System.out.println("Libro encontrado:\n" + libro);
                    return;
                }
            }
        } else {
            System.out.println("El libro no está registrado en la biblioteca.");
        }
    }

    // Método para listar todos los libros en la colección
    private void listarLibros() {
        if (listaLibros.isEmpty()) {
            System.out.println("No hay ningún libro registrado.");
        } else {
            System.out.println("Libros en la biblioteca:");
            for (Libro libro : listaLibros) {
                System.out.println(libro);
            }
        }
    }

    // Método para mostrar el libro más antiguo y el más reciente en la colección
    private void mostrarAntiguedad() {
        if (listaLibros.isEmpty()) {
            System.out.println("No hay libros en la biblioteca.");
            return;
        }

        Libro libroMasAntiguo = listaLibros.stream().min(Libro::compareTo).orElse(null);
        Libro libroMasReciente = listaLibros.stream().max(Libro::compareTo).orElse(null);

        System.out.println("Libro más antiguo:\n" + libroMasAntiguo);
        System.out.println("Libro más reciente:\n" + libroMasReciente);
    }

    // Método para gestionar las opciones seleccionadas en el menú
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> agregarLibro();
            case 2 -> eliminarLibro();
            case 3 -> cantidadLibros();
            case 4 -> buscarLibro();
            case 5 -> listarLibros();
            case 6 -> mostrarAntiguedad();
            case 7 -> {
                System.out.println("Saliendo del programa...");
                entrada.close();
            }
            default -> System.out.println("Opción no válida, introdúcela de nuevo.");
        }
    }
}

package linkedhashset;

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;

public class Ejercicio5 {

    public static void main(String[] args) {
        // Crea una instancia de MenuEjercicio5 y llama a mostrarMenu para iniciar el programa
        MenuEjercicio5 menu = new MenuEjercicio5();
        menu.mostrarMenu();
    }

}

class MenuEjercicio5 {
    // LinkedHashSet para almacenar palabras únicas en el orden de inserción
    LinkedHashSet<String> listaPalabras = new LinkedHashSet<String>();
    // Scanner para leer la entrada del usuario
    Scanner entrada = new Scanner(System.in);
    // Variable para almacenar la opción seleccionada del menú
    int menu = 0;

    public void mostrarMenu() {
        // Bucle que muestra el menú hasta que el usuario elige salir
        do {
            System.out.println("Menu Palabras");
            System.out.println("1. Añadir palabra");
            System.out.println("2. Eliminar palabra");
            System.out.println("3. Mostrar palabra");
            System.out.println("4. Buscar palabra");
            System.out.println("5. Mostrar primera y última palabra");
            System.out.println("6. Salir");
            System.out.print("Escoge opción: ");

            try {
                // Intenta leer y convertir la opción del usuario a entero
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu); // Gestiona la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }

        } while (menu != 6); // Sale del bucle si la opción seleccionada es 6
    }

    private String damePalabra() {
        // Método para obtener una palabra válida del usuario, asegurándose de que no esté vacía ni contenga espacios
        String palabra = "";
        while (true) {
            System.out.print("Introduce la palabra a agregar: ");
            palabra = entrada.nextLine();

            if (palabra.equals("")) {
                System.out.println("La palabra no puede quedar en blanco, introdúcela de nuevo");
            } else if (palabra.contains(" ")) {
                System.out.println("Debe ser una única palabra");
            } else {
                return palabra; // Devuelve la palabra si es válida
            }
        }
    }

    private void borrarPalabra() {
        // Método para eliminar una palabra ingresada por el usuario
        if (listaPalabras.isEmpty()) {
            System.out.println("La lista de palabras está vacía");
        } else {
            String palabra = damePalabra(); // Obtiene la palabra a eliminar
            Iterator<String> it = listaPalabras.iterator(); // Usa un iterador para recorrer el conjunto
            boolean palabraEncontrada = false;
            while (it.hasNext()) {
                String word = it.next();
                
                if (word.equalsIgnoreCase(palabra)) { // Busca la palabra ignorando mayúsculas y minúsculas
                    char respuesta = ' ';
                    palabraEncontrada = true;
                    
                    while (true) {
                        // Solicita confirmación para eliminar la palabra
                        System.out.println("¿Estás seguro de borrar la palabra '" + palabra + "'? (s/n)");
                        respuesta = entrada.nextLine().toLowerCase().charAt(0);
                        
                        if (respuesta != 's' && respuesta != 'n') {
                            System.out.println("La respuesta debe ser (s) o (n), introdúcela de nuevo");
                        } else {
                            break;
                        }
                    }
                    // Verifica la respuesta para continuar o cancelar la eliminación
                    if (respuesta == 'n') {
                        System.out.println("Operación de borrado abortada"); 
                    } else {
                        it.remove(); // Elimina la palabra del conjunto
                        System.out.println("Palabra borrada con éxito");
                    }
                }
                
            }
            if (!palabraEncontrada) {
                System.out.println("La palabra no se encontraba en la lista");
            }
        }
    }

    private void mostrarPalabras() {
        // Muestra todas las palabras en el conjunto en el orden en que fueron añadidas
        if (listaPalabras.isEmpty()) {
            System.out.println("La lista aún está vacía");
        } else {
            System.out.println("Toda la lista de palabras:");
            for (String palabra : listaPalabras) {
                System.out.println(palabra);
            }
        }
    }

    private void buscarPalabra() {
        // Método para buscar una palabra específica en el conjunto
        if (listaPalabras.isEmpty()) {
            System.out.println("La lista aún está vacía");
        } else {
            String palabra = damePalabra(); // Obtiene la palabra a buscar
            
            // Verifica si la palabra está en el conjunto
            if (listaPalabras.contains(palabra)) {
                System.out.println("La palabra '" + palabra + "' está en la lista");
            } else {
                System.out.println("La palabra '" + palabra + "' no está en la lista");
            }
        }
    }

    private void primeraUltimaPalabra() {
        // Muestra la primera y la última palabra añadida al conjunto
        if (listaPalabras.isEmpty()) {
            System.out.println("La lista de palabras está vacía.");
        } else {
            String primeraPalabra = listaPalabras.stream().findFirst().orElse(""); // Obtiene la primera palabra
            String ultimaPalabra = listaPalabras.stream().reduce((first, second) -> second).orElse(""); // Obtiene la última palabra
            System.out.println("La primera palabra de la lista es: " + primeraPalabra);
            System.out.println("La última palabra de la lista es: " + ultimaPalabra);
        }
    }

    private void agregarPalabra() {
        // Método para agregar una nueva palabra al conjunto
        String palabra = damePalabra(); // Obtiene la palabra a añadir

        // Intenta añadir la palabra, muestra un mensaje si ya existe
        if (!listaPalabras.add(palabra)) {
            System.err.println("La palabra ya se encontraba agregada, no se agregará de nuevo");
        } else {
            System.out.println("Palabra agregada con éxito");
        }
    }

    private void gestionarMenu(int menu) {
        // Gestiona las opciones del menú seleccionadas por el usuario
        switch (menu) {
            case 1 -> agregarPalabra(); // Opción para añadir palabra
            case 2 -> borrarPalabra(); // Opción para borrar palabra
            case 3 -> mostrarPalabras(); // Opción para mostrar todas las palabras
            case 4 -> buscarPalabra(); // Opción para buscar una palabra específica
            case 5 -> primeraUltimaPalabra(); // Opción para mostrar primera y última palabra
            case 6 -> {
                System.out.println("Saliendo del programa...");
                entrada.close(); // Cierra el Scanner al salir del programa
                break;
            }
            default -> System.out.println("Opción no contemplada, introdúcela de nuevo"); // Mensaje en caso de opción inválida
        }
    }
}