PULSOFT

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

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

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

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

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

}