Carlos Fernández García

Ejercicio 1

Crea un programa que gestione una lista de tareas utilizando una LinkedList. El programa debe permitir al usuario realizar las siguientes acciones: 1. Añadir una tarea: Solicita al usuario que introduzca el nombre de una tarea y añádela a la lista. 2. Completar la tarea más antigua: Elimina la primera tarea de la lista (la más antigua) tras confirmar con el usuario. 3. Ver todas las tareas: Muestra todas las tareas pendientes en la lista. 4. Ver la próxima tarea: Muestra la tarea que está en primer lugar en la lista, es decir, la más próxima a completar. 5. Salir del programa: Termina la ejecución del programa.


package linkedList;

import java.util.LinkedList;
import java.util.Scanner;

public class Ejercicio1 {

    // Método principal que inicia el programa
    public static void main(String[] args) {
        
        Menu menu = new Menu();  // Instancia del menú
        menu.muestroMenu();  // Muestra el menú al usuario

    }

}

// Clase que representa una Tarea
class Tarea {
    String tarea;  // Atributo que almacena el nombre de la tarea
    
    // Constructor vacío
    public Tarea() {}
    
    // Constructor que recibe el nombre de la tarea
    public Tarea(String tarea) {
        this.tarea = tarea;
    }

    // Método para obtener el nombre de la tarea
    public String getTarea() {
        return tarea;
    }

    // Método para establecer el nombre de la tarea
    public void setTarea(String tarea) {
        this.tarea = tarea;
    }

    // Método que devuelve la representación en cadena del objeto Tarea
    @Override
    public String toString() {
        return "\nTarea --> " + tarea;
    }
    
    // Método para agregar una tarea a la lista de tareas
    public LinkedList<Tarea> agregarTarea(Scanner entrada, LinkedList<Tarea> listaTareas) {
        
        // Bucle que solicita el nombre de la tarea al usuario
        while (true) {
            System.out.println("Introduce el nombre de la tarea");
            this.tarea = entrada.nextLine();  // Captura el nombre ingresado por el usuario
            
            if (this.tarea.equals("")) {  // Si la tarea está vacía, muestra un mensaje de error
                System.out.println("La tarea no puede quedar sin nombre");
            } else {
                break;  // Si el nombre es válido, rompe el bucle
            }
        }
        
        // Crea una nueva tarea y la agrega al final de la lista
        Tarea tarea = new Tarea(this.tarea);
        listaTareas.addLast(tarea);
        
        System.out.println("Tarea agregada correctamente a la lista");
        
        return listaTareas;  // Devuelve la lista actualizada
    }
    
    // Método para comprobar si hay tareas en la lista
    private boolean comprobarTareas(LinkedList<Tarea> listaTareas) {
        if (listaTareas.isEmpty()) {  // Si la lista está vacía, muestra un mensaje
            System.out.println("No hay ninguna tarea pendiente");
            return false;  // Indica que no hay tareas
        } else {
            return true;  // Hay tareas en la lista
        }
    }
    
    // Método para completar la tarea más antigua
    public LinkedList<Tarea> completarTarea(Scanner entrada, LinkedList<Tarea> listaTareas) {
        if (!comprobarTareas(listaTareas)) {  // Comprueba si hay tareas
            return listaTareas;  // Si no hay tareas, devuelve la lista sin cambios
        } else {
            char respuesta = ' ';
            
            // Bucle para confirmar la eliminación de la tarea
            do {
                System.out.println("¿Estas seguro que quieres eliminar la tarea más antigua? (s/n)");
                respuesta = entrada.nextLine().toLowerCase().charAt(0);
                
                if (respuesta != 's' && respuesta != 'n') {
                    System.out.println("La respuesta tiene que ser (s)i o (n)o, introdúcela de nuevo");
                }
            } while (respuesta != 's' && respuesta != 'n');
            
            // Si el usuario confirma, elimina la primera tarea
            if (respuesta == 's') {
                String nombreTarea = listaTareas.getFirst().toString();
                listaTareas.pop();  // Elimina la tarea más antigua
                System.out.println("Tarea " + nombreTarea + " completada con éxito");
                
            } else {
                System.out.println("Operación de eliminación abortada");
            }
            
            return listaTareas;  // Devuelve la lista actualizada
        }
    }
    
    // Método para mostrar todas las tareas pendientes
    public void mostrarTodasTareas(LinkedList<Tarea> listaTareas) {
        if (!comprobarTareas(listaTareas)) {  // Comprueba si hay tareas
            return;  // Si no hay tareas, sale del método
        } else {
            System.out.println("Lista de todas las tareas pendientes:");
            for (Tarea tarea : listaTareas) {  // Recorre y muestra cada tarea
                System.out.println(tarea.toString());
            }
        }
    }
    
    // Método para mostrar la próxima tarea a completar
    public void mostrarProximaTarea(LinkedList<Tarea> listaTareas) {
        if (!comprobarTareas(listaTareas)) {  // Comprueba si hay tareas
            return;  // Si no hay tareas, sale del método
        } else {
            System.out.println("Esta es la próxima tarea a completar: " + listaTareas.getFirst());
        }
    }
    
}

// Clase que gestiona el menú del programa
class Menu {
    Scanner entrada = new Scanner(System.in);  // Objeto Scanner para capturar entradas del usuario
    LinkedList<Tarea> listaTareas = new LinkedList<Tarea>();  // Lista enlazada que almacena las tareas
    Tarea tarea = new Tarea();  // Instancia de la clase Tarea
    
    // Método que muestra el menú al usuario
    public void muestroMenu() {
        int menu = 0;  // Variable para almacenar la opción del menú
        
        // Bucle que muestra el menú hasta que el usuario elige salir
        do {
            System.out.println("MENU TAREAS");
            System.out.println("(1).AÑADIR TAREA");
            System.out.println("(2).COMPLETAR TAREA");
            System.out.println("(3).VER TODAS TAREAS");
            System.out.println("(4).VER LA PROXIMA TAREA");
            System.out.println("(5).SALIR");
            System.out.println("ESCOGER OPCION:");
            
            try {
                menu = Integer.parseInt(entrada.nextLine());  // Captura la opción del menú ingresada por el usuario
                gestionoMenu(menu);  // Gestiona la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
            
        } while (menu != 5);  // Repite el bucle hasta que el usuario elige salir
    }
    
    // Método que gestiona la opción seleccionada del menú
    private void gestionoMenu(int menu) {
        
        switch (menu) {
        case 1 -> listaTareas = tarea.agregarTarea(entrada, listaTareas);  // Añadir tarea
        case 2 -> listaTareas = tarea.completarTarea(entrada, listaTareas);  // Completar tarea
        case 3 -> tarea.mostrarTodasTareas(listaTareas);  // Ver todas las tareas
        case 4 -> tarea.mostrarProximaTarea(listaTareas);  // Ver la próxima tarea
        case 5 -> {
            System.out.println("Saliendo del programa");
            entrada.close();  // Cierra el Scanner al salir del programa
        }
        default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo");
        }
    }
}

Ejercicio 2

Ejercicio: Gestión de una lista de invitados Este programa permite gestionar una lista de invitados utilizando una estructura de datos `LinkedList`. Ofrece las siguientes funcionalidades: 1. Agregar un invitado: El usuario puede añadir invitados al final de la lista. 2. Eliminar un invitado: Se permite al usuario eliminar un invitado por su índice en la lista. 3. Mostrar lista de invitados: Se muestra la lista completa de invitados. 4. Buscar un invitado: El usuario puede buscar un invitado por su nombre. 5. Ordenar lista alfabéticamente: Ordena los invitados en la lista de manera alfabética. 6. Contar invitados: Muestra el número total de invitados en la lista. 7. Actualizar invitado: Permite actualizar el nombre de un invitado por su índice en la lista. 8. Salir: Finaliza el programa. El programa se organiza utilizando dos clases principales: - `Invitado`: Clase que representa a un invitado y gestiona las operaciones relacionadas con los invitados. - `Menu2`: Clase que presenta el menú al usuario y gestiona las opciones seleccionadas. Uso: El usuario interactúa con el programa seleccionando opciones de un menú, lo que desencadena las operaciones correspondientes en la lista de invitados.


package linkedList;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;

public class Ejercicio2 {

    public static void main(String[] args) {
        Menu2 menu=new Menu2();  // Crea un objeto de tipo Menu2
        menu.muestroMenu();  // Llama al método para mostrar el menú de opciones
    }
}

class Invitado implements Comparable<Invitado> {
    String nombre;

    public Invitado() {
        // Constructor vacío
    }

    public Invitado(String nombre) {
        this.nombre = nombre;  // Asigna el nombre del invitado
    }

    public String getNombre() {
        return nombre;  // Devuelve el nombre del invitado
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;  // Establece el nombre del invitado
    }

    @Override
    public String toString() {
        return "Nombre --> " + nombre;  // Representa al invitado como una cadena de texto
    }

    private String nombreInvitado(Scanner entrada) {
        // Método para solicitar al usuario el nombre del invitado, validando que no esté vacío
        while(true) {
            System.out.println("Introduce el nombre del invitado");
            this.nombre = entrada.nextLine();

            if(this.nombre.equals("")) {
                System.out.println("El nombre del invitado no puede quedar vacío, introdúcelo de nuevo");
            } else {
                break;
            }
        }

        return this.nombre;  // Devuelve el nombre introducido
    }

    public LinkedList<Invitado> agregarInvitado(Scanner entrada, LinkedList<Invitado> listaInvitados) {
        // Agrega un nuevo invitado a la lista
        this.nombre = nombreInvitado(entrada);  // Solicita el nombre
        Invitado invitado = new Invitado(this.nombre);

        listaInvitados.addLast(invitado);  // Añade el invitado al final de la lista
        System.out.println("Invitado agregado correctamente al final de la lista");
        return listaInvitados;  // Devuelve la lista actualizada
    }

    private boolean comprobarListaInvitados(LinkedList<Invitado> listaInvitados) {
        // Verifica si la lista de invitados está vacía
        if(listaInvitados.isEmpty()) {
            System.out.println("No hay ningún invitado aún en la lista");
            return false;
        } else {
            return true;
        }
    }

    public void mostrarListaInvitados(LinkedList<Invitado> listaInvitados) {
        // Muestra la lista completa de invitados
        if(!comprobarListaInvitados(listaInvitados)) {
            return;
        } else {
            System.out.println("Esta es la lista de invitados");
            int index = 1;  // Se usa un índice para numerar a los invitados
            for (Invitado invitado : listaInvitados) {
                System.out.println("(" + index + ") --> " +  invitado.toString());
                index++;
            }
        }
    }

    public LinkedList<Invitado> eliminarInvitado(Scanner entrada, LinkedList<Invitado> listaInvitados) {
        // Permite al usuario eliminar un invitado de la lista por su índice
        if(!comprobarListaInvitados(listaInvitados)) {
            return listaInvitados;
        } else {
            mostrarListaInvitados(listaInvitados);  // Muestra la lista para que el usuario elija

            int indice = 0;
            while(true) {
                try {
                    System.out.println("Escoge el invitado a borrar por su índice");
                    indice = Integer.parseInt(entrada.nextLine());

                    if(indice < 1 || indice > listaInvitados.size()) {
                        System.out.println("El índice de invitado tiene que estar comprendido entre 1 y " + listaInvitados.size() + ", introdúcelo de nuevo");
                    } else {
                        break;
                    }
                } catch(NumberFormatException e) {
                    System.out.println("Formato de índice no válido, introdúcelo de nuevo");
                }
            }

            char respuesta = ' ';
            do {
                System.out.println("¿Estás seguro que quieres borrar al invitado " + listaInvitados.get(indice-1).toString() + " (s)i/(n)o ");
                respuesta = entrada.nextLine().toLowerCase().charAt(0);
                if(respuesta != 's' && respuesta != 'n') {
                    System.out.println("La respuesta tiene que ser (s)i o (n)o, introdúcela de nuevo");
                }
            } while(respuesta != 's' && respuesta != 'n');

            if(respuesta == 'n') {
                System.out.println("Operación de borrar invitado cancelada");
            } else {
                String nombreInvitado = listaInvitados.get(indice-1).getNombre().toString();
                listaInvitados.remove(indice-1);  // Elimina al invitado seleccionado
                System.out.println("Invitado --> " + nombreInvitado + " borrado con éxito de la lista");
            }

            return listaInvitados;  // Devuelve la lista actualizada
        }
    }

    public void buscarInvitado(Scanner entrada, LinkedList<Invitado> listaInvitados) {
        // Permite buscar a un invitado por nombre en la lista
        if (!comprobarListaInvitados(listaInvitados)){
            return;
        } else {
            this.nombre = nombreInvitado(entrada);  // Solicita el nombre
            int invitadosEncontrados = 0;

            for (Invitado invitado : listaInvitados) {
                if(invitado.getNombre().equalsIgnoreCase(this.nombre)) {
                    System.out.println("Encontrado " + invitado.getNombre());
                    invitadosEncontrados++;
                }
            }

            if(invitadosEncontrados == 0) {
                System.out.println("No había invitados con ese nombre");
            } else if(invitadosEncontrados == 1) {
                System.out.println("1 invitado encontrado con ese nombre");
            } else {
                System.out.println(invitadosEncontrados + " invitados encontrados con ese nombre");
            }
        }
    }

    public LinkedList<Invitado> ordenarListaAlfabeticamente(LinkedList<Invitado> listaInvitados) {
        // Ordena la lista de invitados alfabéticamente
        if(!comprobarListaInvitados(listaInvitados)) {
            return listaInvitados;
        } else {
            ArrayList<Invitado> listaOrdenada = new ArrayList<>(listaInvitados);  // Crea una lista temporal
            listaOrdenada.sort(null);  // Ordena la lista
            listaInvitados.clear();
            listaInvitados.addAll(listaOrdenada);  // Vuelve a llenar la lista enlazada con los datos ordenados
            System.out.println("La lista ha sido ordenada alfabéticamente");
            mostrarListaInvitados(listaInvitados);
            return listaInvitados;  // Devuelve la lista ordenada
        }
    }

    public int contarInvitados(LinkedList<Invitado> listaInvitados) {
        // Devuelve el número total de invitados en la lista
        return listaInvitados.size();
    }

    public LinkedList<Invitado> actualizarInvitado(Scanner entrada, LinkedList<Invitado> listaInvitados) {
        // Permite actualizar el nombre de un invitado en la lista
        if(!comprobarListaInvitados(listaInvitados)) {
            return listaInvitados;
        } else {
            mostrarListaInvitados(listaInvitados);  // Muestra la lista antes de actualizar

            int indiceActualizo = 0;
            while(true) {
                try {
                    System.out.println("Introduce el índice del invitado a actualizar");
                    indiceActualizo = Integer.parseInt(entrada.nextLine());

                    if(indiceActualizo < 1 || indiceActualizo > listaInvitados.size()) {
                        System.out.println("El índice del invitado tiene que estar comprendido entre 1 y " + listaInvitados.size());
                    } else {
                        break;
                    }
                } catch(NumberFormatException e) {
                    System.out.println("Formato de índice no válido, introdúcelo de nuevo");
                }
            }

            this.nombre = nombreInvitado(entrada);  // Solicita el nuevo nombre
            if(this.nombre.equalsIgnoreCase(listaInvitados.get(indiceActualizo-1).getNombre())) {
                System.out.println("Los nombres coinciden, no se actualizará la lista");
            } else {
                char respuesta = ' ';
                while(true) {
                    System.out.println("¿Estás seguro que quieres actualizar el nombre del invitado " + listaInvitados.get(indiceActualizo-1).getNombre() + "?(s)i/(n)o");
                    respuesta = entrada.nextLine().toLowerCase().charAt(0);

                    if(respuesta == 's' || respuesta == 'n') {
                        break;
                    } else {
                        System.out.println("La respuesta tiene que ser (s)i o (n)o, introdúcela de nuevo");
                    }
                }

                if(respuesta == 's') {
                    listaInvitados.get(indiceActualizo-1).setNombre(this.nombre);
                    System.out.println("Nombre de invitado actualizado a " + this.nombre);
                } else {
                    System.out.println("Operación de actualización abortada");
                }
            }

            return listaInvitados;  // Devuelve la lista actualizada
        }
    }

    @Override
    public int compareTo(Invitado ordenado) {
        // Implementación del método compareTo para ordenar los invitados alfabéticamente
        return this.nombre.compareToIgnoreCase(ordenado.getNombre());
    }
}

class Menu2 {
    Scanner entrada = new Scanner(System.in);
    LinkedList<Invitado> listaInvitados = new LinkedList<Invitado>();  // Lista de invitados
    Invitado invitado = new Invitado();  // Objeto invitado que gestiona las operaciones
    int menu = 0;  // Variable para gestionar la opción del menú

    public void muestroMenu() {
        // Muestra el menú de opciones y gestiona la selección del usuario
        do {
            System.out.println("MENU INVITADOS");
            System.out.println("(1).Agregar invitado");
            System.out.println("(2).Eliminar invitado");
            System.out.println("(3).Mostrar lista invitados");
            System.out.println("(4).Buscar invitado");
            System.out.println("(5).Ordenar lista alfabéticamente");
            System.out.println("(6).Mostrar número de invitados");
            System.out.println("(7).Actualizar invitado");
            System.out.println("(8).Salir");
            System.out.println("Escoge opción:");

            try {
                menu = Integer.parseInt(entrada.nextLine());  // Lee la opción del menú
            } catch(NumberFormatException e) {
                System.err.println("Formato de menú inválido, introdúcelo de nuevo");
            }

            gestionoMenu(menu);  // Llama al método que gestiona las opciones del menú

        } while(menu != 8);  // Repite el menú mientras la opción no sea "Salir"
    }

    private void gestionoMenu(int menu) {
        // Ejecuta la opción seleccionada en el menú
        switch(menu) {
            case 1 -> listaInvitados = invitado.agregarInvitado(entrada, listaInvitados);
            case 2 -> listaInvitados = invitado.eliminarInvitado(entrada, listaInvitados);
            case 3 -> invitado.mostrarListaInvitados(listaInvitados);
            case 4 -> invitado.buscarInvitado(entrada, listaInvitados);
            case 5 -> listaInvitados = invitado.ordenarListaAlfabeticamente(listaInvitados);
            case 6 -> System.out.println("El número total de invitados es --> " + invitado.contarInvitados(listaInvitados));
            case 7 -> listaInvitados = invitado.actualizarInvitado(entrada, listaInvitados);
            case 8 -> {
                System.out.println("Saliendo del programa");
                entrada.close();  // Cierra el Scanner al salir
            }
            default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo");
        }
    }
}

Ejercicio 3

Crea un programa en Java que simule la gestión de pedidos en un restaurante utilizando una LinkedList. El programa debe permitir: Agregar un nuevo pedido: Cada pedido debe contener el nombre del cliente, los platos solicitados (puedes simplificarlo como una cadena de texto) y el total a pagar. Eliminar un pedido: El usuario puede eliminar un pedido en función del nombre del cliente o el número de pedido. Mostrar todos los pedidos: Muestra todos los pedidos pendientes con el nombre del cliente, los platos solicitados y el total a pagar. Ordenar los pedidos por nombre del cliente: Permite ordenar la lista de pedidos en orden alfabético por el nombre del cliente. Buscar un pedido por nombre de cliente: Permite buscar un pedido por el nombre del cliente y mostrar los detalles del pedido si existe. Mostrar el total de ingresos: Muestra el total de dinero generado a partir de los pedidos actuales.


package linkedList;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;

public class Ejercicio3 {
    public static void main(String[] args) {
        Menu3 menu = new Menu3(); // Crea una instancia de la clase Menu3
        menu.mostrarMenu(); // Llama al método para mostrar el menú
    }
}

// Clase Pedido que implementa Comparable para permitir la ordenación
class Pedido implements Comparable<Pedido> {
    String nombreCliente; // Almacena el nombre del cliente
    String platosPedidos; // Almacena los platos pedidos por el cliente
    double totalPagar; // Almacena el total a pagar por el pedido
    
    // Constructor por defecto
    public Pedido() {
    }

    // Constructor que inicializa todos los atributos de Pedido
    public Pedido(String nombreCliente, String platosPedidos, double totalPagar) {
        this.nombreCliente = nombreCliente; // Inicializa nombreCliente
        this.platosPedidos = platosPedidos; // Inicializa platosPedidos
        this.totalPagar = totalPagar; // Inicializa totalPagar
    }

    // Métodos getter y setter para nombreCliente
    public String getNombreCliente() {
        return nombreCliente;
    }

    public void setNombreCliente(String nombreCliente) {
        this.nombreCliente = nombreCliente;
    }

    // Métodos getter y setter para platosPedidos
    public String getPlatosPedidos() {
        return platosPedidos;
    }

    public void setPlatosPedidos(String platosPedidos) {
        this.platosPedidos = platosPedidos;
    }

    // Métodos getter y setter para totalPagar
    public double getTotalPagar() {
        return totalPagar;
    }

    public void setTotalPagar(double totalPagar) {
        this.totalPagar = totalPagar;
    }

    // Método toString que devuelve una representación del pedido en forma de cadena
    @Override
    public String toString() {
        return "\n Nombre del cliente --> " + nombreCliente + "\nPlatos pedidos --> " + platosPedidos + "\nTotal a pagar --> "
                + totalPagar + "€";
    }
    
    // Método privado para obtener un campo de texto del usuario
    private String campoTexto(Scanner entrada, String campo) {
        String dato = ""; // Inicializa la variable para almacenar el dato
        
        while (true) {
            System.out.println("Introduce el campo " + campo); // Solicita al usuario que introduzca el campo
            dato = entrada.nextLine(); // Lee la entrada del usuario
            
            // Verifica si el campo está vacío
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacio, introducelo de nuevo");
            } else {
                return dato; // Devuelve el dato válido
            }
        }
    }
    
    // Método privado para obtener un número decimal del usuario
    private double campoDoble(Scanner entrada, String campo) {
        double dato; // Inicializa la variable para almacenar el dato
        
        while (true) {
            try {
                System.out.println("Introduce el campo " + campo); // Solicita al usuario que introduzca el campo
                dato = Double.parseDouble(entrada.nextLine()); // Convierte la entrada a double
                
                // Verifica si el dato es negativo
                if (dato < 0) {
                    System.out.println("El " + campo + " no puede ser negativo introducelo de nuevo");
                } else {
                    return dato; // Devuelve el dato válido
                }
            } catch (NumberFormatException e) {
                System.out.println("Formato de moneda no valido, introducelo de nuevo"); // Mensaje de error en caso de formato inválido
            }
        }
    }
    
    // Método para agregar un nuevo pedido a la lista de pedidos
    public LinkedList<Pedido> agregarPedido(Scanner entrada, LinkedList<Pedido> listaPedidos) {
        // Obtiene los datos del nuevo pedido
        this.nombreCliente = campoTexto(entrada, "nombre del cliente");
        this.platosPedidos = campoTexto(entrada, "platos pedidos");
        this.totalPagar = campoDoble(entrada, "total a pagar");
        
        Pedido pedido = new Pedido(this.nombreCliente, this.platosPedidos, this.totalPagar); // Crea un nuevo objeto Pedido
        listaPedidos.addLast(pedido); // Agrega el pedido a la lista
        
        System.out.println("Pedido realizado correctamente"); // Mensaje de confirmación
        return listaPedidos; // Devuelve la lista de pedidos actualizada
    }
    
    // Método privado para comprobar si la lista de pedidos está vacía
    private boolean comprobarListaPedidos(LinkedList<Pedido> listaPedidos) {
        if (listaPedidos.isEmpty()) {
            System.out.println("La lista de pedidos esta vacia"); // Mensaje si la lista está vacía
            return false; // Retorna false si la lista está vacía
        } else {
            return true; // Retorna true si hay pedidos en la lista
        }
    }
    
    // Método para eliminar un pedido, llamando al menú de eliminación
    public void eliminarPedido(Scanner entrada, LinkedList<Pedido> listaPedidos) {
        if (!comprobarListaPedidos(listaPedidos)) { // Verifica si la lista está vacía
            return; // Sale del método si la lista está vacía
        } else {
            Menu3 menu = new Menu3(); // Crea una instancia del menú
            menu.menuEliminar(); // Llama al menú de eliminación
        }
    }
    
    // Método para eliminar pedidos por nombre del cliente
    public LinkedList<Pedido> eliminarPorNombre(Scanner entrada, LinkedList<Pedido> listaPedidos) {
        if (!comprobarListaPedidos(listaPedidos)) { // Verifica si la lista está vacía
            return listaPedidos; // Retorna la lista sin cambios
        } else {
            this.nombreCliente = campoTexto(entrada, "nombre de cliente"); // Solicita el nombre del cliente
            
            Iterator<Pedido> it = listaPedidos.iterator(); // Crea un iterador para la lista de pedidos
            int contadorPedidos = 0; // Contador de pedidos encontrados
            
            // Recorre la lista de pedidos
            while (it.hasNext()) {
                Pedido pedido = it.next(); // Obtiene el siguiente pedido
                // Compara el nombre del cliente con el nombre proporcionado
                if (pedido.getNombreCliente().equalsIgnoreCase(this.nombreCliente)) {
                    contadorPedidos++; // Incrementa el contador si hay coincidencia
                }
            }
            
            // Mensaje si no se encontraron pedidos con ese nombre
            if (contadorPedidos == 0) {
                System.out.println("No hay pedidos con ese nombre de cliente");
            } else {
                char respuesta = ' '; // Variable para almacenar la respuesta del usuario
                
                // Solicita confirmación para eliminar los pedidos
                while (true) {
                    System.out.println("¿Seguro que quieres borrar los pedidos de " + this.nombreCliente + "?(s)i/(n)o");
                    respuesta = entrada.nextLine().toLowerCase().charAt(0); // Lee la respuesta
                    
                    // Verifica que la respuesta sea válida
                    if (respuesta != 's' && respuesta != 'n') {
                        System.out.println("Tienes que responder (s) o (n), introduce respuesta de nuevo");
                    } else {
                        break; // Sale del bucle si la respuesta es válida
                    }
                }
                
                // Si el usuario responde 'no', aborta la operación
                if (respuesta == 'n') {
                    System.out.println("Operacion de borrado de pedidos abortada");
                } else {
                    // Recorre la lista para eliminar los pedidos correspondientes
                    Iterator<Pedido> itBorro = listaPedidos.iterator();
                    while (itBorro.hasNext()) {
                        Pedido pedido = itBorro.next(); // Obtiene el siguiente pedido
                        // Compara el nombre del cliente con el nombre proporcionado
                        if (pedido.getNombreCliente().equalsIgnoreCase(this.nombreCliente)) {
                            itBorro.remove(); // Elimina el pedido de la lista
                        }
                    }
                    
                    // Mensaje de éxito dependiendo de la cantidad de pedidos borrados
                    if (contadorPedidos == 1) {
                        System.out.println("Un pedido borrado con exito");
                    } else {
                        System.out.println(contadorPedidos + " borrados con exito");
                    }
                }
            }
            return listaPedidos; // Retorna la lista de pedidos actualizada
        }
    }
    
    // Método para eliminar un pedido por número
    public LinkedList<Pedido> eliminarPorNumero(Scanner entrada, LinkedList<Pedido> listaPedidos) {
        if (!comprobarListaPedidos(listaPedidos)) { // Verifica si la lista está vacía
            return listaPedidos; // Retorna la lista sin cambios
        } else {
            mostrarListaPedidos(listaPedidos); // Muestra la lista de pedidos
            
            int numeroPedido = 0; // Inicializa la variable para almacenar el número del pedido
            
            // Solicita un número de pedido válido
            while (true) {
                try {
                    System.out.println("Introduce el numero de pedido a borrar");
                    numeroPedido = Integer.parseInt(entrada.nextLine()); // Lee y convierte la entrada a entero
                } catch (NumberFormatException e) {
                    System.out.println("Formato de numero de pedido invalido, introducelo de nuevo"); // Mensaje de error en caso de formato inválido
                }
                
                // Verifica que el número esté dentro del rango
                if (numeroPedido < 1 || numeroPedido > listaPedidos.size()) {
                    System.out.println("El numero de pedido tiene que estar entre 1 y " + listaPedidos.size() + ", introducelo de nuevo");
                } else {
                    break; // Sale del bucle si el número es válido
                }
            }
            
            char respuesta = ' '; // Variable para almacenar la respuesta del usuario
            
            // Solicita confirmación para eliminar el pedido
            while (true) {
                System.out.println("¿Estas seguro que quieres borrar el pedido " + numeroPedido + " del cliente " + listaPedidos.get(numeroPedido - 1).getNombreCliente() + "? (s)/(n)");
                respuesta = entrada.nextLine().toLowerCase().charAt(0); // Lee la respuesta
                
                // Verifica que la respuesta sea válida
                if (respuesta != 's' && respuesta != 'n') {
                    System.out.println("La respuesta tiene que ser (s)i o (n)o, introducela de nuevo");
                } else {
                    break; // Sale del bucle si la respuesta es válida
                }
            }
            
            // Si el usuario responde 'no', aborta la operación
            if (respuesta == 'n') {
                System.out.println("Operacion de eliminacion de pedido por numero abortada");
            } else {
                listaPedidos.remove(numeroPedido - 1); // Elimina el pedido de la lista
                System.out.println("Pedido borrado correctamente"); // Mensaje de éxito
            }
            
            return listaPedidos; // Retorna la lista de pedidos actualizada
        }
    }
    
    // Método para mostrar todos los pedidos en la lista
    public void mostrarListaPedidos(LinkedList<Pedido> listaPedidos) {
        if (!comprobarListaPedidos(listaPedidos)) { // Verifica si la lista está vacía
            return; // Sale del método si la lista está vacía
        } else {
            System.out.println("Lista de todos los pedidos"); // Mensaje que indica que se mostrará la lista
            int index = 1; // Inicializa el índice para enumerar los pedidos
            
            // Recorre la lista de pedidos y los muestra
            for (Pedido pedido : listaPedidos) {
                System.out.println("Pedido Nº " + index + pedido.toString()); // Muestra el pedido
                index++; // Incrementa el índice
            }
        }
    }

    // Método para ordenar la lista de pedidos alfabéticamente
    public LinkedList<Pedido> ordenarListaAlfabeticamente(LinkedList<Pedido> listaPedidos) {
        if (!comprobarListaPedidos(listaPedidos)) { // Verifica si la lista está vacía
            return listaPedidos; // Retorna la lista sin cambios
        } else {
            ArrayList<Pedido> listaOrdenada = new ArrayList<>(listaPedidos); // Crea una nueva lista a partir de la lista original
            listaOrdenada.sort(null); // Ordena la lista alfabéticamente
            listaPedidos.clear(); // Limpia la lista original
            listaPedidos.addAll(listaOrdenada); // Añade los pedidos ordenados a la lista original
            System.out.println("La lista ha sido ordenada alfabeticamente"); // Mensaje de confirmación
            mostrarListaPedidos(listaPedidos); // Muestra la lista ordenada
            return listaPedidos; // Retorna la lista de pedidos ordenada
        }
    }
    
    // Método para buscar pedidos por el nombre del cliente
    public void buscarClienteNombre(Scanner entrada, LinkedList<Pedido> listaPedidos) {
        if (!comprobarListaPedidos(listaPedidos)) { // Verifica si la lista está vacía
            return; // Sale del método si la lista está vacía
        } else {
            String nombreBuscar = campoTexto(entrada, "nombre del cliente"); // Solicita el nombre del cliente
            
            int contadorNombres = 0; // Contador de nombres encontrados
            
            // Recorre la lista de pedidos
            for (Pedido pedido : listaPedidos) {
                // Compara el nombre del cliente con el nombre proporcionado
                if (pedido.getNombreCliente().equalsIgnoreCase(nombreBuscar)) {
                    System.out.println(pedido.toString()); // Muestra el pedido si hay coincidencia
                    contadorNombres++; // Incrementa el contador
                }
            }
            
            // Mensaje según el número de coincidencias encontradas
            if (contadorNombres == 0) {
                System.out.println("Ningun cliente encontrado con ese nombre");
            } else if (contadorNombres == 1) {
                System.out.println("1 cliente encontrado con ese nombre");
            } else {
                System.out.println(contadorNombres + " clientes encontrados con ese nombre");
            }
        }
    }
    
    // Método para mostrar el total de ingresos de todos los pedidos
    public void mostrarTotalIngresos(LinkedList<Pedido> listaPedidos) {
        if (!comprobarListaPedidos(listaPedidos)) { // Verifica si la lista está vacía
            return; // Sale del método si la lista está vacía
        } else {
            double sumaTotal = 0.0; // Inicializa la suma total
            
            // Recorre la lista de pedidos y suma el total a pagar
            for (Pedido pedido : listaPedidos) {
                sumaTotal += pedido.getTotalPagar(); // Suma el total a pagar de cada pedido
            }
            
            // Muestra el total de pedidos y su valor
            System.out.println("Hay un total de " + listaPedidos.size() + " pedidos y su valor asciende a " + String.format("%.2f", sumaTotal) + "€");
        }
    }

    // Método para comparar dos pedidos alfabéticamente por el nombre del cliente
    @Override
    public int compareTo(Pedido ordenar) {
        return this.nombreCliente.compareToIgnoreCase(ordenar.getNombreCliente()); // Compara los nombres de los clientes
    }
}



class Menu3 {
    int menu = 0; // Variable para almacenar la opción del menú principal
    LinkedList<Pedido> listaPedidos = new LinkedList<Pedido>(); // Lista para almacenar los pedidos
    Pedido pedido = new Pedido(); // Crea una nueva instancia de la clase Pedido
    Scanner entrada = new Scanner(System.in); // Scanner para leer la entrada del usuario
    
    // Método para mostrar el menú de eliminación de pedidos
    public void menuEliminar() {
        int menuEliminar = 0; // Variable para almacenar la opción del menú de eliminación
        do {
            System.out.println("MENU ELIMINAR");
            System.out.println("(1).Eliminar por nombre del cliente"); // Opción para eliminar por nombre
            System.out.println("(2).Eliminar por numero de pedido"); // Opción para eliminar por número
            System.out.println("(3).Volver a menu principal"); // Opción para volver al menú principal
            System.out.println("Escoge opcion"); // Solicita al usuario que elija una opción
            
            try {
                // Lee la opción elegida por el usuario y la convierte a entero
                menuEliminar = Integer.parseInt(entrada.nextLine());
                // Llama al método para gestionar la opción seleccionada
                gestionarMenuEliminar(menuEliminar);
            } catch (NumberFormatException e) {
                // Maneja el error si el formato no es válido
                System.out.println("Formato de menu no valido, introducelo de nuevo");
            }
            
        } while (menuEliminar != 3); // Repite hasta que el usuario elija salir al menú principal
    }
    
    // Método para mostrar el menú principal
    public void mostrarMenu() {
        do {
            System.out.println("MENU PEDIDOS");
            System.out.println("(1).Añadir pedido"); // Opción para añadir un pedido
            System.out.println("(2).Eliminar pedido"); // Opción para eliminar un pedido
            System.out.println("(3).Mostrar todos los pedidos"); // Opción para mostrar todos los pedidos
            System.out.println("(4).ordenar por nombre del cliente"); // Opción para ordenar pedidos
            System.out.println("(5).Buscar pedido por nombre del cliente"); // Opción para buscar por nombre
            System.out.println("(6).Sumar el valor total de los pedidos"); // Opción para mostrar el total
            System.out.println("(7).Salir del programa"); // Opción para salir del programa
            System.out.println("Escoge opcion"); // Solicita al usuario que elija una opción
            
            try {
                // Lee la opción elegida por el usuario y la convierte a entero
                menu = Integer.parseInt(entrada.nextLine());
                // Llama al método para gestionar la opción seleccionada
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                // Maneja el error si el formato no es válido
                System.out.println("Formato de menu no valido, introducelo de nuevo");
            }
            
        } while (menu != 7); // Repite hasta que el usuario elija salir
    }
    
    // Método para gestionar el menú principal según la opción seleccionada
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> listaPedidos = pedido.agregarPedido(entrada, listaPedidos); // Añade un nuevo pedido
            case 2 -> menuEliminar(); // Llama al menú de eliminación
            case 3 -> pedido.mostrarListaPedidos(listaPedidos); // Muestra todos los pedidos
            case 4 -> listaPedidos = pedido.ordenarListaAlfabeticamente(listaPedidos); // Ordena los pedidos alfabéticamente
            case 5 -> pedido.buscarClienteNombre(entrada, listaPedidos); // Busca pedidos por nombre del cliente
            case 6 -> pedido.mostrarTotalIngresos(listaPedidos); // Muestra el total de ingresos de los pedidos
            case 7 -> { 
                System.out.println("Saliendo del programa"); // Mensaje de salida
                entrada.close(); // Cierra el scanner
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo"); // Mensaje si la opción no es válida
        }
    }
    
    // Método para gestionar el menú de eliminación según la opción seleccionada
    private void gestionarMenuEliminar(int menuEliminar) {
        switch (menuEliminar) {
            case 1 -> listaPedidos = pedido.eliminarPorNombre(entrada, listaPedidos); // Elimina por nombre del cliente
            case 2 -> listaPedidos = pedido.eliminarPorNumero(entrada, listaPedidos); // Elimina por número de pedido
            case 3 -> System.out.println("Volviendo a menu principal"); // Mensaje al volver al menú principal
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo"); // Mensaje si la opción no es válida
        }
    }
}

Ejercicio 4

Crea una aplicación en Java para gestionar una biblioteca de libros utilizando la clase LinkedList. El programa permitirá realizar las siguientes acciones a través de un menú: Añadir libro: El usuario introducirá el título, el autor y el año de publicación del libro. Valida que los campos no estén vacíos y que el año de publicación sea mayor o igual a 868 (año del primer libro conocido) y no mayor que el año actual. Eliminar libro: El usuario introducirá el título del libro que desea eliminar. Si existen varios libros con el mismo título, el programa los eliminará todos. Muestra un mensaje indicando cuántos libros fueron eliminados. Mostrar todos los libros: Muestra una lista con todos los libros presentes en la biblioteca, incluyendo título, autor y año de publicación. Si no hay libros registrados, muestra un mensaje indicando que la biblioteca está vacía. Buscar libros por autor: El usuario introducirá el nombre de un autor, y el programa mostrará todos los libros registrados bajo ese autor. Si no se encuentran libros, muestra un mensaje indicándolo. Ordenar libros por título: Ordena los libros en la biblioteca alfabéticamente por su título y muestra la lista de libros ordenada. Salir: Cierra la aplicación. Requisitos: Utiliza la clase LinkedList para gestionar la lista de libros. Implementa la clase Libros con los atributos titulo, autor y anio para representar los libros. Implementa un menú interactivo que permita al usuario seleccionar las opciones descritas. Valida las entradas de los usuarios (por ejemplo, el año de publicación debe ser un número válido dentro de un rango razonable). Elimina libros utilizando la clase Iterator para evitar problemas de modificación concurrente durante la iteración.

package linkedList;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;

public class Ejercicio4 {

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

// Clase que representa un libro
class Libros implements Comparable<Libros> {
	String titulo; // Título del libro
	String autor; // Autor del libro
	int anio; // Año de publicación del libro
	
	public Libros() {
		// Constructor vacío
	}

	public Libros(String titulo, String autor, int anio) {
		this.titulo = titulo; // Inicializar el título
		this.autor = autor; // Inicializar el autor
		this.anio = anio; // Inicializar el año de publicación
	}

	public String getTitulo() {
		return titulo; // Obtener el título del libro
	}

	public void setTitulo(String titulo) {
		this.titulo = titulo; // Establecer el título del libro
	}

	public String getAutor() {
		return autor; // Obtener el autor del libro
	}

	public void setAutor(String autor) {
		this.autor = autor; // Establecer el autor del libro
	}

	public int getAnio() {
		return anio; // Obtener el año de publicación
	}

	public void setAnio(int anio) {
		this.anio = anio; // Establecer el año de publicación
	}

	@Override
	public String toString() {
		// Representación en cadena del libro
		return "\nTitulo --> " + titulo + "\nAutor --> " + autor + "\nAño -->" + anio;
	}
	
	// Método para solicitar un campo de texto al usuario
	private String campoTexto(Scanner entrada, String campo) {
		String dato = "";
		
		while (true) {
			System.out.println("Introduce el campo " + campo + " del libro");
			dato = entrada.nextLine();
			
			// Verificar que el campo no esté vacío
			if (dato.equals("")) {
				System.out.println("El campo " + campo + " no puede quedar vacio, introducelo de nuevo");
			} else {
				return dato; // Retornar el dato ingresado
			}
		}
	}
	
	// Método para solicitar un año de publicación (entero) al usuario
	private int campoEntero(Scanner entrada) {
		int dato = 0;
		
		while (true) {
			try {
				System.out.println("Introduce el año de publicacion del libro");
				dato = Integer.parseInt(entrada.nextLine());
				
				// Verificar que el año esté dentro de un rango válido
				if (dato < 868 || dato > LocalDate.now().getYear()) {
					System.out.println("El año de publicacion no puede ser inferior a 868 año que se conoce el primer libro publicado y el año actual " + LocalDate.now().getYear() + ", introducelo de nuevo");
				} else {
					return dato; // Retornar el año ingresado
				}
			} catch (NumberFormatException e) {
				System.out.println("Formato de año de publicacion no valido, introducelo de nuevo");
			}
		}
	}
	
	// Método para agregar un libro a la lista
	public LinkedList<Libros> agregarLibro(Scanner entrada, LinkedList<Libros> listaLibros) {
		this.titulo = campoTexto(entrada, "titulo"); // Obtener el título
		this.autor = campoTexto(entrada, "autor"); // Obtener el autor
		this.anio = campoEntero(entrada); // Obtener el año de publicación
		
		// Crear un nuevo libro y añadirlo a la lista
		Libros libro = new Libros(this.titulo, this.autor, this.anio);
		listaLibros.add(libro);
		System.out.println("Libro añadido a la biblioteca correctamente");
		
		return listaLibros; // Retornar la lista actualizada
	}
	
	// Método para comprobar si la lista de libros está vacía
	private boolean comprobarListaLibros(LinkedList<Libros> listaLibros) {
		if (listaLibros.isEmpty()) {
			System.out.println("La bibloteca aun no tiene libros dados de alta");
			return false; // Retornar falso si la lista está vacía
		} else {
			return true; // Retornar verdadero si la lista no está vacía
		}
	}
	
	// Método para eliminar un libro de la lista
	public LinkedList<Libros> eliminarLibro(Scanner entrada, LinkedList<Libros> listaLibros) {
		if (!comprobarListaLibros(listaLibros)) {
			return listaLibros; // Si la lista está vacía, retornar sin cambios
		} else {
			this.titulo = campoTexto(entrada, "titulo a eliminar"); // Obtener el título a eliminar
			
			int contadorEliminados = 0; // Contador de libros eliminados
			Iterator<Libros> it = listaLibros.iterator(); // Iterador para recorrer la lista
			
			// Recorrer la lista para buscar y eliminar el libro
			while (it.hasNext()) {
				Libros libro = it.next();
				if (libro.getTitulo().equalsIgnoreCase(this.titulo)) {
					it.remove(); // Eliminar el libro de la lista
					contadorEliminados++;
				}
			}
			
			// Mensajes dependiendo de cuántos libros fueron eliminados
			if (contadorEliminados == 0) {
				System.out.println("No habia libros con ese titulo");
			} else if (contadorEliminados == 1) {
				System.out.println("1 libro borrado con ese titulo");
			} else {
				System.out.println(contadorEliminados + " eliminados con ese titulo");
			}
			
			// Mensaje si la lista queda vacía
			if (listaLibros.size() == 0) {
				System.out.println("Era el ultimo libro de la biblioteca");
			}
			
			return listaLibros; // Retornar la lista actualizada
		}
	}
	
	// Método para mostrar todos los libros de la lista
	public void mostrarLibros(LinkedList<Libros> listaLibros) {
		if (!comprobarListaLibros(listaLibros)) {
			return; // Si la lista está vacía, retornar sin hacer nada
		} else {
			System.out.println("Lista de todos los libros de la bibloteca");
			
			// Recorrer la lista y mostrar cada libro
			for (Libros libros : listaLibros) {
				System.out.println(libros.toString());
			} 
			
			System.out.println("La bibloteca cuenta con un total de " + listaLibros.size() + " libros");
		}
	}
	
	// Método para buscar libros por autor
	public void buscarAutor(Scanner entrada, LinkedList<Libros> listaLibros) {
		if (!comprobarListaLibros(listaLibros)) {
			return; // Si la lista está vacía, retornar sin hacer nada
		} else {
			this.autor = campoTexto(entrada, "autor a buscar"); // Obtener el autor a buscar
			
			int contadorAutores = 0; // Contador de libros del autor
			// Recorrer la lista y mostrar los libros del autor
			for (Libros libros : listaLibros) {
				if (libros.getAutor().equalsIgnoreCase(this.autor)) {
					System.out.println(libros.toString());
					contadorAutores++;
				}
			}
			
			// Mensajes dependiendo de cuántos libros del autor fueron encontrados
			if (contadorAutores == 0) {
				System.out.println("El autor " + this.autor + " no tiene libros en esta bibloteca dados de alta"); 
			} else if (contadorAutores == 1) {
				System.out.println(this.autor + " tiene 1 libro dado de alta en esta bibloteca");
			} else {
				System.out.println(this.autor + " tiene " + contadorAutores + " libros dados de alta en esta bibloteca");
			}
		}
	}
	
	// Método para ordenar la lista de libros alfabéticamente por título
	public LinkedList<Libros> ordenarBiblioteca(LinkedList<Libros> listaLibros) {
		if (!comprobarListaLibros(listaLibros)) {
			return listaLibros; // Si la lista está vacía, retornar sin cambios
		} else {
			ArrayList<Libros> listaOrdenada = new ArrayList<Libros>(listaLibros); // Crear una lista temporal
			listaOrdenada.sort(null); // Ordenar la lista temporal
			listaLibros.clear(); // Limpiar la lista original
			listaLibros.addAll(listaOrdenada); // Añadir los libros ordenados a la lista original
			System.out.println("Lista de libros ordenada por titulo");
			mostrarLibros(listaLibros); // Mostrar la lista ordenada
			
			return listaLibros; // Retornar la lista ordenada
		}
	}

	@Override
	public int compareTo(Libros ordenar) {
		// Comparar libros por título (ignorar mayúsculas)
		return this.titulo.compareToIgnoreCase(ordenar.getTitulo());
	}
}

// Clase que maneja el menú de la biblioteca
class MenuLibro {
	LinkedList<Libros> listaLibros = new LinkedList<Libros>(); // Lista de libros
	Libros libro = new Libros(); // Instancia de Libros para operaciones
	Scanner entrada = new Scanner(System.in); // Scanner para entrada de datos
	int menuLibro = 0; // Opción del menú elegida por el usuario
	
	// Método para mostrar el menú de opciones
	public void mostrarMenu() {
		do {
			// Mostrar opciones del menú
			System.out.println("BIBLIOTECA");
			System.out.println("(1).Añadir libro");
			System.out.println("(2).Borrar libro");
			System.out.println("(3).Mostrar todos los libros");
			System.out.println("(4).Buscar libros por autor");
			System.out.println("(5).Ordenar por titulo");
			System.out.println("(6).Salir");
			System.out.println("Escoge opcion:");
			
			try {
				menuLibro = Integer.parseInt(entrada.nextLine()); // Leer opción del menú
				gestionarMenu(menuLibro); // Llamar al método para gestionar la opción
			} catch (NumberFormatException e) {
				System.out.println("Formato de menú no valido, introducelo de nuevo");
			}
			
		} while (menuLibro != 6); // Continuar hasta que el usuario decida salir
	}
	
	// Método para gestionar las opciones del menú
	private void gestionarMenu(int menuLibro) {
		switch (menuLibro) {
		case 1 -> listaLibros = libro.agregarLibro(entrada, listaLibros); // Añadir libro
		case 2 -> listaLibros = libro.eliminarLibro(entrada, listaLibros); // Borrar libro
		case 3 -> libro.mostrarLibros(listaLibros); // Mostrar todos los libros
		case 4 -> libro.buscarAutor(entrada, listaLibros); // Buscar libros por autor
		case 5 -> libro.ordenarBiblioteca(listaLibros); // Ordenar libros por título
		case 6 -> {
			System.out.println("Saliendo del programa de biblioteca"); // Mensaje al salir
			entrada.close(); // Cerrar el Scanner
		}
		default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo"); // Opción no válida
		}
	}
}

Ejercicio 5

Crea un programa que gestione un inventario de productos utilizando una LinkedList para almacenar información sobre cada producto. Cada producto debe tener los siguientes atributos: Nombre (String) Código de producto (String) Cantidad en stock (int) Precio unitario (double) Tu programa debe permitir al usuario realizar las siguientes acciones: Añadir un nuevo producto: Solicita al usuario que introduzca el nombre, código, cantidad en stock y precio unitario, y añade el producto a la lista. Eliminar un producto: Permite al usuario eliminar un producto de la lista. Para esto, debe introducir el código del producto a eliminar. Si el producto no existe, muestra un mensaje adecuado. Mostrar todos los productos: Muestra en consola todos los productos almacenados en la lista, con su nombre, código, cantidad y precio unitario. Buscar un producto por código: Permite al usuario introducir un código de producto y muestra la información del producto correspondiente. Actualizar la cantidad de un producto: Permite al usuario introducir el código de un producto y la nueva cantidad, y actualiza la cantidad en stock del producto. Calcular el valor total del inventario: Muestra el valor total del inventario multiplicando la cantidad de cada producto por su precio unitario.

package linkedList;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;

public class Ejercicio5 {

    public static void main(String[] args) {
        // Crea una instancia de MenuInventario y muestra el menú de opciones al usuario
        MenuInventario menu = new MenuInventario();
        menu.mostrarMenu();
    }

}

class Inventario {
    // Atributos de la clase Inventario
    String nombre;
    String codigo;
    int cantidad;
    double precio;

    // Constructor por defecto
    public Inventario() {
    }

    // Constructor que inicializa todos los atributos del producto
    public Inventario(String nombre, String codigo, int cantidad, double precio) {
        this.nombre = nombre;
        this.codigo = codigo;
        this.cantidad = cantidad;
        this.precio = precio;
    }

    // Getters y setters para los atributos
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public int getCantidad() {
        return cantidad;
    }

    public void setCantidad(int cantidad) {
        this.cantidad = cantidad;
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    // Método toString para mostrar la información de un producto
    @Override
    public String toString() {
        return "\nNombre --> " + nombre + "\nCodigo --> " + codigo + "\nCantidad --> " + cantidad + "\nPrecio --> " + String.format("%.2f", precio) + "€";
    }

    // Método para validar y obtener campos de texto (nombre o código) desde el usuario
    private String campoTexto(Scanner entrada, String campo) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el campo " + campo + " del producto");
            dato = entrada.nextLine();
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return dato;
            }
        }
    }

    // Método para validar y obtener un entero (cantidad) desde el usuario
    private int campoEntero(Scanner entrada) {
        int dato = 0;
        while (true) {
            try {
                System.out.println("Introduce el stock del producto");
                dato = Integer.parseInt(entrada.nextLine());
                if (dato < 0) {
                    System.out.println("El stock no puede ser negativo, introdúcelo de nuevo");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de stock no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para validar y obtener un doble (precio) desde el usuario
    private double campoDoble(Scanner entrada) {
        double dato = 0.0;
        while (true) {
            try {
                System.out.println("Introduce el P.V.P del producto");
                dato = Double.parseDouble(entrada.nextLine());
                if (dato < 0) {
                    System.out.println("El P.V.P no puede ser negativo, introdúcelo de nuevo");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de P.V.P no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para agregar un producto al inventario
    public LinkedList<Inventario> agregarProducto(Scanner entrada, LinkedList<Inventario> listaInventario) {
        // Recoge datos del usuario para crear un nuevo producto
        this.nombre = campoTexto(entrada, "nombre");
        this.codigo = campoTexto(entrada, "codigo");
        this.cantidad = campoEntero(entrada);
        this.precio = campoDoble(entrada);
        
        // Crea un nuevo producto y lo añade a la lista
        Inventario producto = new Inventario(this.nombre, this.codigo, this.cantidad, this.precio);
        listaInventario.add(producto);
        
        System.out.println("Producto dado de alta correctamente en el inventario");
        return listaInventario;
    }

    // Método para comprobar si el inventario está vacío
    private boolean comprobarLista(LinkedList<Inventario> listaInventario) {
        if (listaInventario.isEmpty()) {
            System.out.println("El inventario está vacío");
            return false;
        } else {
            return true;
        }
    }

    // Método para eliminar un producto del inventario usando su código
    public LinkedList<Inventario> eliminarProducto(Scanner entrada, LinkedList<Inventario> listaInventario) {
        if (!comprobarLista(listaInventario)) {
            return listaInventario;
        } else {
            this.codigo = campoTexto(entrada, "código a buscar");
            boolean encontrado = false;

            Iterator<Inventario> it = listaInventario.iterator();

            // Recorre la lista y elimina el producto que coincida con el código
            while (it.hasNext()) {
                Inventario producto = it.next();
                if (producto.getCodigo().equalsIgnoreCase(this.codigo)) {
                    it.remove();
                    encontrado = true;
                }
            }

            if (!encontrado) {
                System.out.println("El código del producto no se encuentra en el inventario");
            } else {
                System.out.println("Producto borrado correctamente");
            }

            return listaInventario;
        }
    }

    // Método para mostrar todos los productos del inventario
    public void mostrarInventario(LinkedList<Inventario> listaInventario) {
        if (!comprobarLista(listaInventario)) {
            return;
        } else {
            System.out.println("INVENTARIO DE TODOS LOS PRODUCTOS DEL ALMACÉN");
            for (Inventario inventario : listaInventario) {
                System.out.println(inventario.toString());
            }
        }
    }

    // Método para buscar un producto por código y mostrar sus detalles
    public void buscarProducto(Scanner entrada, LinkedList<Inventario> listaInventario) {
        if (!comprobarLista(listaInventario)) {
            return;
        } else {
            this.codigo = campoTexto(entrada, "código de búsqueda");
            boolean encontrado = false;
            for (Inventario inventario : listaInventario) {
                if (inventario.getCodigo().equals(this.codigo)) {
                    System.out.println(inventario.toString());
                    encontrado = true;
                }
            }
            if (!encontrado) {
                System.out.println("El producto no se encuentra en el almacén");
            }
        }
    }

    // Método para actualizar el precio de un producto usando su código
    public LinkedList<Inventario> actualizarProducto(Scanner entrada, LinkedList<Inventario> listaInventario) {
        if (!comprobarLista(listaInventario)) {
            return listaInventario;
        } else {
            this.codigo = campoTexto(entrada, "código de búsqueda");
            boolean encontrado = false;
            for (Inventario inventario : listaInventario) {
                if (inventario.getCodigo().equals(this.codigo)) {
                    this.precio = campoDoble(entrada);
                    inventario.setPrecio(this.precio);
                    encontrado = true;
                }
            }

            if (!encontrado) {
                System.out.println("El producto no se encuentra en el almacén");
            } else {
                System.out.println("Precio actualizado correctamente");
            }

            return listaInventario;
        }
    }

    // Método para calcular y mostrar el valor total del inventario
    public void calcularTotalInventario(LinkedList<Inventario> listaInventario) {
        if (!comprobarLista(listaInventario)) {
            return;
        } else {
            double sumaTotal = 0.0;
            for (Inventario inventario : listaInventario) {
                sumaTotal += inventario.getPrecio() * inventario.getCantidad();
            }

            System.out.println("El inventario consta de " + listaInventario.size() + " productos y su valor total es de " + String.format("%.2f", sumaTotal) + "€");
        }
    }

}

class MenuInventario {

    // Atributos del menú y la lista de inventario
    LinkedList<Inventario> listaInventario = new LinkedList<>();
    Scanner entrada = new Scanner(System.in);
    Inventario inventario = new Inventario();
    int menuInventario = 0;

    // Método para mostrar el menú al usuario
    public void mostrarMenu() {

        do {
            // Muestra las opciones disponibles en el menú
            System.out.println("INVENTARIO");
            System.out.println("(1).Añadir producto");
            System.out.println("(2).Eliminar producto");
            System.out.println("(3).Mostrar todos los productos");
            System.out.println("(4).Buscar producto por código");
            System.out.println("(5).Actualizar producto");
            System.out.println("(6).Valor total del inventario");
            System.out.println("(7).Salir del programa");
            System.out.println("Escoge opción:");

            try {
                // Captura y gestiona la opción elegida por el usuario
                menuInventario = Integer.parseInt(entrada.nextLine());
                gestionMenu(menuInventario);
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }

        } while (menuInventario != 7); // Repite hasta que el usuario decida salir
    }

    // Método que gestiona la opción seleccionada por el usuario
    private void gestionMenu(int menuInventario) {
        switch (menuInventario) {
            case 1 -> listaInventario = inventario.agregarProducto(entrada, listaInventario); // Agrega un producto
            case 2 -> listaInventario = inventario.eliminarProducto(entrada, listaInventario); // Elimina un producto
            case 3 -> inventario.mostrarInventario(listaInventario); // Muestra el inventario
            case 4 -> inventario.buscarProducto(entrada, listaInventario); // Busca un producto por código
            case 5 -> listaInventario = inventario.actualizarProducto(entrada, listaInventario); // Actualiza el producto
            case 6 -> inventario.calcularTotalInventario(listaInventario); // Calcula el valor total del inventario
            case 7 -> {
                System.out.println("Saliendo del programa");
                entrada.close(); // Cierra el Scanner al salir del programa
            }
            default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo"); // Valida opciones incorrectas
        }
    }

}