Carlos Fernández García

Ejercicio 1

Crea un programa en Java que permita gestionar una lista de nombres en la que no se repitan y que mantenga el orden de inserción. El programa debe: Permitir agregar nombres a la lista. Mostrar todos los nombres en el orden en que fueron agregados. Eliminar un nombre específico de la lista. Mostrar la cantidad de nombres únicos que hay en la lista. Comprobar si un nombre dado ya está en la lista. Utiliza LinkedHashSet para almacenar los nombres y asegura que no haya duplicados, pero manteniendo el orden de inserción.

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++;
                }
            }
        }
    }
}

Ejercicio 2

* Crea un programa en Java que gestione un conjunto de números enteros utilizando LinkedHashSet. El programa debe: Permitir al usuario agregar números enteros al conjunto. Mostrar todos los números en el orden en que fueron agregados. Eliminar un número específico del conjunto. Mostrar la cantidad de números únicos en el conjunto. Comprobar si un número dado ya está en el conjunto. Mostrar el número mayor y menor presentes en el conjunto. *

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");
            }
        }
    }
}

Ejercicio 3

Crea un programa en Java que permita gestionar un registro de eventos importantes en una lista que: Permita agregar fechas (año, mes, y día) representando eventos importantes. Asegure que no haya fechas duplicadas y mantenga el orden en que se ingresaron. Permita eliminar una fecha específica de la lista. Muestre la cantidad total de fechas registradas. Verifique si una fecha dada ya está en la lista. Encuentre y muestre la fecha más reciente y la más antigua en la lista. Utiliza LinkedHashSet para almacenar las fechas en formato LocalDate, asegurando la unicidad y el orden de inserción.

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.");
            }
        }
    }
}

Ejercicio 4

Crea un programa en Java que permita gestionar una colección de libros únicos en una biblioteca utilizando LinkedHashSet. Cada libro debe tener un título, un autor y un año de publicación. El programa debe permitir: Agregar un nuevo libro: Solicita al usuario el título, autor y año de publicación. Si el libro ya existe en la colección (basado en el título y el autor), muestra un mensaje indicando que el libro ya está registrado. Eliminar un libro: Permite eliminar un libro de la colección ingresando el título y el autor. Si el libro no se encuentra en la colección, muestra un mensaje informativo. Mostrar la cantidad total de libros: Muestra el número total de libros en la colección. Buscar un libro: Permite verificar si un libro (según título y autor) está en la colección. Si existe, muestra sus detalles; si no, informa al usuario. Listar todos los libros: Muestra todos los libros de la colección en el orden en que fueron agregados, con sus detalles (título, autor y año de publicación). Mostrar el libro más reciente y el más antiguo: Encuentra y muestra el libro publicado más recientemente y el más antiguo en la colección. Si no hay libros, muestra un mensaje adecuado. Requisitos: Usa LinkedHashSet para almacenar los objetos de tipo Libro, de modo que no haya duplicados y se respete el orden de inserción. Define la clase Libro con los atributos mencionados (título, autor y año de publicación), y sobrescribe los métodos equals() y hashCode() para comparar los libros correctamente. Usa métodos y estructuras de control para implementar cada una de las funcionalidades solicitadas en el programa.


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.");
        }
    }
}

Ejercicio 5

Crea un programa en Java que permita al usuario gestionar un conjunto de palabras únicas en una lista utilizando LinkedHashSet. El programa debe ofrecer las siguientes opciones: Añadir palabra: Permite al usuario agregar una palabra al conjunto. Si la palabra ya existe, muestra un mensaje indicándolo y no la agrega de nuevo. Eliminar palabra: Permite eliminar una palabra del conjunto ingresando su valor. Si la palabra no está en la lista, muestra un mensaje informativo. Mostrar palabras: Muestra todas las palabras en el orden en que fueron agregadas. Buscar palabra: Permite verificar si una palabra específica está en la lista. Si está presente, muestra un mensaje confirmando su existencia. Mostrar la primera y última palabra añadida: Muestra la primera y la última palabra que se añadieron al conjunto en el orden de inserción. Si el conjunto está vacío, muestra un mensaje adecuado. Requisitos: Usa LinkedHashSet para almacenar las palabras, asegurando que no haya duplicados y que se respete el orden de inserción. Implementa métodos para cada una de las funcionalidades y usa estructuras de control y validación de entrada donde sea necesario.

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
        }
    }
}