Carlos Fernández García

Ejercicio 1

Crea un programa en Java que simule una lista de espera en una consulta médica. Requisitos: Utiliza una ArrayDeque para almacenar los nombres de los pacientes. El programa debe ofrecer las siguientes opciones: Agregar un paciente al final de la lista. Atender al siguiente paciente (remover el primer nombre de la lista y mostrarlo en pantalla). Mostrar la lista actual de pacientes en espera. Terminar el programa cuando el usuario lo indique.

package arraydeque;

import java.util.ArrayDeque;
import java.util.Scanner;

public class Ejercicio1 {

    public static void main(String[] args) {
        // Crear instancia del menú y mostrarlo al usuario
        MenuEjercicio1 menu = new MenuEjercicio1();
        menu.mostrarMenu();
    }
}

class Paciente {
    // ArrayDeque para gestionar la lista de pacientes
    ArrayDeque<String> listaPacientes = new ArrayDeque<>();
    String nombre = "";

    // Método para agregar un paciente a la lista de espera
    public void agregarPaciente(Scanner entrada) {
        while (true) {
            System.out.println("Agrega un nombre de paciente a la lista de espera:");
            this.nombre = entrada.nextLine();

            // Validar que el nombre no esté vacío
            if (this.nombre.trim().isBlank()) {
                System.out.println("El nombre no puede quedar vacío, introdúcelo de nuevo.");
            } else {
                // Agregar al final de la lista
                listaPacientes.addLast(nombre);
                System.out.println("El paciente ha sido agregado al final de la lista de espera con éxito.");
                break;
            }
        }
    }

    // Método para atender al primer paciente en la lista
    public void atenderPaciente() {
        if (listaPacientes.isEmpty()) {
            // Si no hay pacientes en espera
            System.out.println("No hay pacientes en lista de espera.");
        } else {
            // Obtener y eliminar al primer paciente
            String pacienteAtendido = listaPacientes.getFirst();
            listaPacientes.removeFirst();
            System.out.println("El paciente '" + pacienteAtendido + "' que estaba en primer lugar en la lista de espera ha sido atendido.");

            // Informar sobre el número de pacientes restantes
            if (listaPacientes.size() == 0) {
                System.out.println("Lista de pacientes vacía.");
            } else if (listaPacientes.size() == 1) {
                System.out.println("Queda 1 paciente en lista de espera.");
            } else {
                System.out.println("Quedan " + listaPacientes.size() + " pacientes en lista de espera.");
            }
        }
    }

    // Método para mostrar la lista de pacientes en espera
    public void mostrarLista() {
        if (listaPacientes.isEmpty()) {
            // Si la lista está vacía
            System.out.println("No hay pacientes en lista de espera.");
        } else {
            // Mostrar cada paciente en la lista con su posición
            int orden = 0;
            for (String paciente : listaPacientes) {
                orden++;
                System.out.println(orden + ". " + paciente);
            }

            // Informar sobre el número de pacientes restantes
            if (listaPacientes.size() == 1) {
                System.out.println("Queda 1 paciente en lista de espera.");
            } else {
                System.out.println("Quedan " + listaPacientes.size() + " pacientes en lista de espera.");
            }
        }
    }
}

class MenuEjercicio1 {
    int menu = 0; // Opción seleccionada por el usuario
    Scanner entrada = new Scanner(System.in); // Scanner para entrada de datos
    Paciente paciente = new Paciente(); // Instancia de la clase Paciente

    // Método para mostrar el menú principal
    public void mostrarMenu() {
        do {
            // Mostrar opciones del menú
            System.out.println("Hospital");
            System.out.println("1. Agregar Paciente");
            System.out.println("2. Atender Paciente");
            System.out.println("3. Ver lista de espera");
            System.out.println("4. Salir del programa");
            System.out.println("Escoge opción:");

            try {
                // Leer la opción seleccionada
                menu = Integer.parseInt(entrada.nextLine());
                // Gestionar la opción seleccionada
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                // Manejar entrada inválida
                System.err.println("Formato de menú no válido, introdúcelo de nuevo.");
            }
        } while (menu != 4); // Repetir hasta que el usuario elija salir
    }

    // Método para ejecutar la acción correspondiente a la opción seleccionada
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> paciente.agregarPaciente(entrada); // Agregar paciente
            case 2 -> paciente.atenderPaciente(); // Atender paciente
            case 3 -> paciente.mostrarLista(); // Mostrar lista de pacientes
            case 4 -> {
                // Salir del programa
                System.out.println("Saliendo del programa hospital...");
                entrada.close();
            }
            default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo.");
        }
    }
}

Ejercicio 2

Crea un programa en Java que utilice una ArrayDeque para gestionar una lista de tareas pendientes en una aplicación de productividad. Requisitos: El programa debe ofrecer las siguientes opciones: Agregar una tarea urgente al inicio: Permite añadir una nueva tarea al comienzo de la lista. Completar la última tarea: Obtiene y elimina la tarea ubicada al final de la lista, mostrándola como completada. Ver la próxima tarea a realizar: Muestra la tarea ubicada al inicio de la lista sin eliminarla. Mostrar todas las tareas pendientes: Itera por la lista para mostrar las tareas actuales. Salir del programa: Finaliza la ejecución del programa. Notas adicionales: Si se intenta completar una tarea cuando la lista está vacía, debe mostrarse un mensaje indicando que no hay tareas pendientes. El programa debe permitir gestionar las tareas de manera dinámica hasta que el usuario decida salir.

package arraydeque;

import java.util.ArrayDeque;
import java.util.Scanner;

public class Ejercicio2 {

    public static void main(String[] args) {
        // Instancia el objeto del menú y muestra las opciones
        MenuEjercicio2 menu = new MenuEjercicio2();
        menu.mostrarMenu();
    }
}

// Clase que maneja las tareas en la lista
class Tarea {
    // Deque que almacena las tareas
    private ArrayDeque<String> listaTareas = new ArrayDeque<>();
    private String tarea = "";

    // Método para agregar una tarea urgente al principio de la lista
    public void agregarTarea(Scanner entrada) {
        while (true) {
            System.out.println("Introduce la tarea urgente:");
            this.tarea = entrada.nextLine();

            // Verifica si la tarea no está vacía
            if (this.tarea.trim().isBlank()) {
                System.out.println("El nombre de la tarea no puede quedar vacío, introdúcelo de nuevo");
            } else {
                listaTareas.addFirst(tarea);  // Añade la tarea al principio
                System.out.println("La tarea ha sido agregada como urgente al principio de la lista");
                break;  // Sale del ciclo cuando se añade la tarea correctamente
            }
        }
    }

    // Método para completar una tarea, dependiendo de si es urgente o no
    public void completarTarea(boolean urgente) {
        if (listaTareas.isEmpty()) {
            System.out.println("No hay tareas en la lista para completar");  // Mensaje si la lista está vacía
        } else {
            if (urgente) {
                this.tarea = listaTareas.getFirst();  // Obtiene la tarea urgente (primera en la lista)
                listaTareas.removeFirst();  // Elimina la tarea de la lista
                System.out.println("La tarea urgente '" + this.tarea + "' ha sido completada");
            } else {
                this.tarea = listaTareas.getLast();  // Obtiene la tarea no urgente (última en la lista)
                listaTareas.removeLast();  // Elimina la tarea de la lista
                System.out.println("La tarea no urgente '" + this.tarea + "' ha sido completada");
            }
        }
    }

    // Método para ver la próxima tarea a realizar (tanto urgente como no urgente)
    public void proximaTarea() {
        if (listaTareas.isEmpty()) {
            System.out.println("No hay tareas en la lista");
        } else if (listaTareas.size() == 1) {
            System.out.println("La próxima tarea urgente y no urgente es -> " + listaTareas.getFirst());  // Si solo hay una tarea, es tanto urgente como no urgente
        } else {
            System.out.println("La próxima tarea urgente es -> " + listaTareas.getFirst());  // Muestra la tarea urgente
            System.out.println("La próxima tarea no urgente es -> " + listaTareas.getLast());  // Muestra la tarea no urgente
        }
    }

    // Método para mostrar todas las tareas pendientes
    public void listaTareas() {
        if (listaTareas.isEmpty()) {
            System.out.println("No hay tareas en la lista");
        } else {
            int indice = 0;
            for (String tarea : listaTareas) {
                indice++;
                System.out.println("Tarea Nº" + indice + " --> " + tarea);  // Muestra las tareas y su índice
            }

            // Muestra el número total de tareas en la lista
            System.out.println("Hay " + listaTareas.size() + " tareas en la lista de espera");
        }
    }
}

// Clase que gestiona el menú de opciones
class MenuEjercicio2 {
    private int menu = 0;  // Variable para almacenar la opción seleccionada
    private Scanner entrada = new Scanner(System.in);  // Objeto Scanner para leer la entrada del usuario
    private Tarea tarea = new Tarea();  // Objeto Tarea que gestionará las tareas

    // Método para mostrar el menú y procesar las opciones
    public void mostrarMenu() {
        do {
            // Muestra las opciones del menú
            System.out.println("Menú Tareas");
            System.out.println("1. Agregar tarea urgente");
            System.out.println("2. Completar última tarea");
            System.out.println("3. Completar tarea urgente");
            System.out.println("4. Ver próxima tarea");
            System.out.println("5. Mostrar todas las tareas");
            System.out.println("6. Salir del programa");
            System.out.println("Escoge opción:");

            try {
                menu = Integer.parseInt(entrada.nextLine());  // Lee la opción del usuario
                gestionarMenu(menu);  // Llama al método para gestionar la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");  // Mensaje de error si la opción no es válida
            }

        } while (menu != 6);  // Continúa hasta que el usuario seleccione la opción 6 (salir)
    }

    // Método para gestionar las opciones del menú
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> tarea.agregarTarea(entrada);  // Opción 1: Agregar tarea urgente
            case 2 -> tarea.completarTarea(false);  // Opción 2: Completar última tarea (no urgente)
            case 3 -> tarea.completarTarea(true);  // Opción 3: Completar tarea urgente
            case 4 -> tarea.proximaTarea();  // Opción 4: Ver próxima tarea
            case 5 -> tarea.listaTareas();  // Opción 5: Mostrar todas las tareas
            case 6 -> {
                System.out.println("Saliendo del programa de tareas ...");
                entrada.close();  // Cierra el objeto Scanner al finalizar el programa
            }
            default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo");  // Mensaje de error si la opción no está en el menú
        }
    }
}

Ejercicio 3

Crea un programa en Java que simule un navegador web utilizando una ArrayDeque para gestionar el historial de navegación. Requisitos: El programa debe ofrecer las siguientes opciones en un menú: Visitar una nueva página: Agrega una nueva URL al final del historial. Retroceder: Elimina la última página visitada (como si se regresara en la navegación). Avanzar: Permite restaurar la última página eliminada (siempre y cuando no se haya visitado una nueva página desde la última eliminación). Mostrar historial actual: Muestra todas las páginas visitadas en orden de navegación. Borrar historial: Limpia completamente el historial de navegación. Salir del programa. El programa debe manejar casos donde: Se intente retroceder o avanzar cuando no haya páginas disponibles para esa acción. El historial esté vacío. Utiliza una segunda ArrayDeque para almacenar las páginas eliminadas al retroceder, lo que permitirá implementar la funcionalidad de "Avanzar". Permite al usuario interactuar de forma dinámica hasta que decida salir del programa. Nota adicional: El programa debe validar las entradas del usuario y mostrar mensajes claros para las diferentes acciones.

package arraydeque;

import java.util.ArrayDeque;
import java.util.Scanner;

public class Ejercicio3 {

    public static void main(String[] args) {
        // Se crea una instancia del menú y se muestra al usuario.
        MenuEjercicio3 menu = new MenuEjercicio3();
        menu.mostrarMenu();
    }
}

class Navegador {
    // ArrayDeque para almacenar las páginas activas.
    private ArrayDeque<String> paginas = new ArrayDeque<String>();
    // ArrayDeque para almacenar las páginas eliminadas al retroceder.
    private ArrayDeque<String> paginasVisitadas = new ArrayDeque<String>();
    private String pagina;

    // Método para agregar una nueva URL al navegador.
    public void agregarUrl(Scanner entrada) {
        while (true) {
            System.out.println("Introduce la URL de la web:");
            this.pagina = entrada.nextLine();

            // Validación para que la URL no esté vacía ni contenga espacios.
            if (this.pagina.trim().isEmpty() || this.pagina.contains(" ")) {
                System.out.println("La URL no puede estar vacía ni contener espacios en blanco. Introdúcela de nuevo.");
            } else {
                // Agrega la URL al historial activo y limpia el historial de páginas visitadas.
                paginas.addFirst(pagina);
                paginasVisitadas.clear();
                System.out.println("Pagina agregada al navegador");
                break;
            }
        }
    }

    // Método para retroceder en el historial del navegador.
    public void retrocederUrl() {
        if (paginas.isEmpty()) {
            System.out.println("El navegador esta en blanco");
        } else {
            // Mueve la página actual al historial de páginas visitadas.
            String paginaHistorico = paginas.removeFirst();
            paginasVisitadas.addFirst(paginaHistorico);
            System.out.println("Pagina '" + paginaHistorico + "' pasada al historial");
        }
    }

    // Método para avanzar en el historial de páginas visitadas.
    public void avanzarUrl() {
        if (paginasVisitadas.isEmpty()) {
            System.out.println("El historial esta en blanco");
        } else {
            // Restaura la última página del historial al navegador activo.
            String paginaHistorico = paginasVisitadas.removeFirst();
            paginas.addFirst(paginaHistorico);
            System.out.println("Pagina '" + paginaHistorico + "' restaurada");
        }
    }

    // Método para mostrar el historial actual del navegador.
    public void mostrarHistorialActual() {
        if (paginas.isEmpty() && paginasVisitadas.isEmpty()) {
            System.out.println("No hay paginas en el historial");
        } else {
            int indice = 0;

            // Muestra las páginas activas actualmente.
            if (!paginas.isEmpty()) {
                System.out.println("******* Paginas activas actualmente *******");
                for (String pagina : paginas) {
                    indice++;
                    System.out.println(indice + " --> " + pagina);
                }
            }

            // Muestra las páginas pasadas al historial.
            if (!paginasVisitadas.isEmpty()) {
                System.out.println("******* Paginas pasadas a historial *******");
                for (String pagina : paginasVisitadas) {
                    indice++;
                    System.out.println(indice + " --> " + pagina);
                }
            }
        }
    }

    // Método para borrar todo el historial del navegador.
    public void borrarHistorial() {
        paginas.clear();
        paginasVisitadas.clear();
        System.out.println("Historial del navegador borrado");
    }
}

class MenuEjercicio3 {

    private int menu = 0;
    private Scanner entrada = new Scanner(System.in);
    private Navegador navegador = new Navegador();

    // Método principal que muestra el menú y permite la interacción con el usuario.
    public void mostrarMenu() {
        do {
            // Opciones disponibles para el usuario.
            System.out.println("Menu Navegador");
            System.out.println("1.Agregar url");
            System.out.println("2.Retroceder url");
            System.out.println("3.Avanzar url");
            System.out.println("4.Mostrar historial actual");
            System.out.println("5.Borrar historial");
            System.out.println("6.Salir");
            System.out.println("Escoge opcion:");

            try {
                // Intenta leer la opción seleccionada por el usuario.
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                // Mensaje de error si la entrada no es válida.
                System.err.println("Formato de menu no valido, introducelo de nuevo");
            }
        } while (menu != 6);
    }

    // Método que gestiona las acciones del menú según la opción seleccionada.
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> navegador.agregarUrl(entrada); // Agregar nueva URL.
            case 2 -> navegador.retrocederUrl(); // Retroceder en el historial.
            case 3 -> navegador.avanzarUrl(); // Avanzar en el historial.
            case 4 -> navegador.mostrarHistorialActual(); // Mostrar historial actual.
            case 5 -> navegador.borrarHistorial(); // Borrar todo el historial.
            case 6 -> {
                // Cerrar el programa y liberar recursos.
                System.out.println("Cerrando navegador ...");
                entrada.close();
            }
            default -> System.out.println("Opcion no contemplada, introducela de nuevo"); // Mensaje para opción inválida.
        }
    }
}

Ejercicio 4

Crea un programa en Java que simule un cajero automático utilizando una ArrayDeque para gestionar un historial de transacciones bancarias. Requisitos: Funciones principales del programa: Depositar dinero: Permite al usuario ingresar un monto, que se registra en el historial de transacciones. Retirar dinero: Permite al usuario retirar un monto, validando que haya fondos suficientes. Registra la transacción en el historial. Mostrar historial de transacciones: Muestra las últimas 10 transacciones en orden cronológico (del más reciente al más antiguo). Deshacer última transacción: Permite revertir la última transacción realizada (ya sea un depósito o un retiro). Salir: Finaliza el programa. Detalles adicionales: El saldo inicial de la cuenta será de 0. Las transacciones deben ser almacenadas en formato de texto, por ejemplo: "Depósito: +100.00 EUR" o "Retiro: -50.00 EUR". Si el historial supera las 10 transacciones, elimina las más antiguas automáticamente. Valida las entradas del usuario para evitar montos negativos o errores de formato. Asegúrate de manejar correctamente los casos en los que: No haya suficiente saldo para un retiro. El historial esté vacío al intentar deshacer una transacción.

/* Programa que simula un cajero automático utilizando ArrayDeque para gestionar un historial de transacciones bancarias.
 * Incluye funcionalidades para depositar dinero, retirar dinero, mostrar el historial, deshacer la última transacción
 * y salir del programa. 
 */

package arraydeque;

import java.util.ArrayDeque;
import java.util.Iterator;
import java.util.Scanner;

public class Ejercicio4 {

    public static void main(String[] args) {
        // Instancia del menú para iniciar el programa
        MenuEjercicio4 menu = new MenuEjercicio4();
        menu.mostrarMenu();
    }
}

class Transaccion {
    // Cola doble para almacenar las transacciones
    private ArrayDeque<Double> transaccion = new ArrayDeque<Double>();
    private double cantidad;

    // Método para crear una transacción de ingreso
    public void crearIngreso(Scanner entrada) {
        while (true) {
            try {
                System.out.println("¿Qué cantidad deseas ingresar?");
                this.cantidad = Double.parseDouble(entrada.nextLine());

                // Validación de monto positivo
                if (this.cantidad < 0) {
                    System.out.println("Las cantidades tienen que ser mayores que 0");
                } else {
                    // Se añade el monto al principio del historial
                    transaccion.addFirst(this.cantidad);
                    System.out.println("La transacción se realizó correctamente, vuelva cuando quiera");
                    break;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de ingreso no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para crear una transacción de retiro
    public void crearRetiro(Scanner entrada) {
        // Cálculo del saldo actual
        double saldo = transaccion.stream().mapToDouble(Double::doubleValue).sum();

        if (saldo == 0) {
            System.out.println("No es posible hacer retiros de dinero, tu saldo está a 0€");
        } else {
            while (true) {
                try {
                    System.out.println("¿Qué cantidad deseas retirar?");
                    this.cantidad = Double.parseDouble(entrada.nextLine());

                    // Validación de montos positivos
                    if (this.cantidad < 0) {
                        System.out.println("Introduce el retiro de dinero sin signos, el programa se encargará de restarlo de su cuenta");
                    } else {
                        // Verificación de saldo suficiente
                        if (this.cantidad > saldo) {
                            System.out.println("Saldo insuficiente, no se realizará el retiro de dinero de su cuenta");
                            break;
                        }
                        // Registro del retiro como negativo
                        transaccion.addFirst(-this.cantidad);
                        System.out.println("La transacción se realizó correctamente, vuelva cuando quiera");
                        break;
                    }
                } catch (NumberFormatException e) {
                    System.err.println("Formato de retiro no válido, introdúcelo de nuevo");
                }
            }
        }
    }

    // Método para deshacer la última transacción
    public void deshacerTransaccion(Scanner entrada) {
        if (transaccion.isEmpty()) {
            System.out.println("No hay transacciones que mostrar");
        } else {
            char respuesta = ' ';
            while (true) {
                // Identificación del tipo de transacción (retiro o ingreso)
                String tipo = "";
                if (transaccion.getFirst() < 0) {
                    tipo = "Retiro";
                } else {
                    tipo = "Ingreso";
                }
                System.out.println("¿Estás seguro que quieres borrar la última transacción (" + tipo + ")" + transaccion.getFirst() + "?(s)(n)");
                respuesta = entrada.nextLine().toLowerCase().charAt(0);

                // Validación de entrada del usuario
                if (respuesta != 's' && respuesta != 'n') {
                    System.out.println("La respuesta tiene que ser (s) o (n), introdúcela de nuevo");
                } else {
                    break;
                }
            }

            // Elimina la transacción si el usuario confirma la acción
            if (respuesta == 'n') {
                System.out.println("Acción de borrado cancelada");
            } else {
                transaccion.removeFirst();
                System.out.println("Transacción eliminada");
            }
        }
    }

    // Método para mostrar las transacciones almacenadas
    public void mostrarTransacciones() {
        if (transaccion.isEmpty()) {
            System.out.println("No hay transacciones que mostrar");
        } else {
            if (transaccion.size() < 10) {
                System.out.println("Todas sus transacciones son " + transaccion.size());
                // Itera y muestra todas las transacciones
                Iterator<Double> it = transaccion.iterator();
                int indice = 0;
                while (it.hasNext()) {
                    indice++;
                    this.cantidad = it.next();
                    System.out.println("Nº" + indice + this.cantidad + "€");
                }
            } else {
                System.out.println("Todas sus transacciones son " + transaccion.size());
                // Muestra solo las últimas 10 transacciones
                Iterator<Double> it = transaccion.iterator();
                int indice = 0;
                while (indice < 10) {
                    indice++;
                    this.cantidad = it.next();
                    System.out.println("Nº" + indice + this.cantidad + "€");
                }
            }
            // Muestra el saldo total
            System.out.println("Su saldo es de --> " + transaccion.stream().mapToDouble(Double::doubleValue).sum() + "€");
        }
    }
}

class MenuEjercicio4 {
    private int menu = 0;
    private Scanner entrada = new Scanner(System.in);
    private Transaccion transaccion = new Transaccion();

    // Método para mostrar el menú principal
    public void mostrarMenu() {
        do {
            System.out.println("Menu Transacciones");
            System.out.println("1.Depositar dinero");
            System.out.println("2.Retirar dinero");
            System.out.println("3.Mostrar 10 últimas transacciones");
            System.out.println("4.Deshacer última transacción");
            System.out.println("5.Salir del programa bancario ...");
            System.out.println("Escoge opción:");

            try {
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de opción no válido, introdúcelo de nuevo");
            }
        } while (menu != 5);
    }

    // Método para gestionar las opciones del menú
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> transaccion.crearIngreso(entrada); // Opción de ingreso
            case 2 -> transaccion.crearRetiro(entrada); // Opción de retiro
            case 3 -> transaccion.mostrarTransacciones(); // Mostrar historial
            case 4 -> transaccion.deshacerTransaccion(entrada); // Deshacer transacción
            case 5 -> {
                System.out.println("Cerrando programa");
                entrada.close(); // Cierra el Scanner al salir
            }
            default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo");
        }
    }
}

Ejercicio 5

Crea un programa en Java que simule la gestión de tickets en un cine utilizando la colección ArrayDeque. El programa debe permitir realizar las siguientes operaciones: Añadir un ticket vendido al final de la cola: Cada ticket tiene un número único generado automáticamente (puedes empezar desde el número 1 y aumentar consecutivamente). Llamar al próximo cliente para entrar a la sala: Esto implica retirar el ticket que esté al inicio de la cola y mostrar su número. Si no hay tickets en la cola, muestra un mensaje indicando que no hay clientes esperando. Cancelar la última venta de ticket: Elimina el ticket más reciente de la cola, indicando el número del ticket cancelado. Si no hay tickets, muestra un mensaje de que no hay ventas para cancelar. Mostrar todos los tickets en la cola: Lista todos los números de ticket, desde el primero vendido hasta el último. Si la cola está vacía, indica que no hay tickets. Salir del programa: Finaliza la ejecución del programa.

package arraydeque;

import java.util.ArrayDeque;
import java.util.Scanner;

public class Ejercicio5 {

    public static void main(String[] args) {
        MenuEjercicio5 menu = new MenuEjercicio5();
        menu.mostrarMenu(); // Inicia el menú principal para gestionar tickets.
    }

}

class Ticket {
    ArrayDeque<Integer> colaTickets = new ArrayDeque<Integer>(); // Cola para almacenar los tickets generados.
    int numeroTicket = 0; // Contador para asignar números únicos a los tickets.

    /* Método para generar y añadir un ticket al final de la cola */
    public void venderTicket() {
        numeroTicket++; // Incrementa el número del ticket.
        colaTickets.addLast(numeroTicket); // Añade el ticket al final de la cola.
        System.out.println("Ticket generado con exito y puesto en cola");
    }

    /* Método para atender al próximo cliente (elimina el primer ticket de la cola) */
    public void llamarCliente() {
        if (colaTickets.isEmpty()) { // Verifica si la cola está vacía.
            System.out.println("No quedan clientes por atender");
        } else {
            System.out.println("Se atendera el cliente numero -> " + colaTickets.getFirst());
            colaTickets.removeFirst(); // Elimina el primer ticket de la cola.
            System.out.println("Cliente atendido con exito");

            // Muestra el estado de la cola después de atender al cliente.
            if (colaTickets.size() == 0) {
                System.out.println("Era el ultimo cliente de la cola");
            } else if (colaTickets.size() == 1) {
                System.out.println("Queda un ultimo cliente en la cola");
            } else {
                System.out.println("Quedan " + colaTickets.size() + " clientes en la cola");
            }
        }
    }

    /* Método para mostrar todos los tickets en la cola */
    public void mostrarCola() {
        if (colaTickets.isEmpty()) { // Verifica si la cola está vacía.
            System.out.println("No quedan clientes por atender");
        } else {
            System.out.println("Lista de clientes");
            int indice = 0; // Índice para numerar los tickets en la lista.

            // Recorre la cola e imprime cada ticket con su posición en la cola.
            for (Integer cliente : colaTickets) {
                indice++;
                System.out.println(indice + ". Nº cliente -> " + cliente);
            }
        }
    }

    /* Método para cancelar la última venta realizada (elimina el último ticket de la cola) */
    public void cancelarVenta() {
        if (colaTickets.isEmpty()) { // Verifica si la cola está vacía.
            System.out.println("No quedan clientes por atender");
        } else {
            System.out.println("Se cancelara el cliente numero -> " + colaTickets.getLast());
            colaTickets.removeLast(); // Elimina el último ticket de la cola.
            System.out.println("Venta cancelada con exito");

            // Muestra el estado de la cola después de cancelar la venta.
            if (colaTickets.size() == 0) {
                System.out.println("Era la unica venta de la cola");
            } else if (colaTickets.size() == 1) {
                System.out.println("Queda un ultimo cliente en la cola");
            } else {
                System.out.println("Quedan " + colaTickets.size() + " clientes en la cola");
            }
        }
    }
}

class MenuEjercicio5 {
    int menu = 0; // Variable para almacenar la opción seleccionada en el menú.
    Scanner entrada = new Scanner(System.in); // Objeto Scanner para leer la entrada del usuario.
    Ticket ticket = new Ticket(); // Objeto de la clase Ticket para gestionar las operaciones.

    /* Método principal para mostrar el menú y manejar las opciones seleccionadas */
    public void mostrarMenu() {
        do {
            // Imprime las opciones del menú en consola.
            System.out.println("Menu tickets");
            System.out.println("1.Añadir ticket al final");
            System.out.println("2.Llamar proximo cliente");
            System.out.println("3.Cancelar ultima venta");
            System.out.println("4.Mostrar tickets en cola");
            System.out.println("5.Salir del programa");
            System.out.println("Escoge opcion:");

            try {
                menu = Integer.parseInt(entrada.nextLine()); // Lee la opción ingresada por el usuario.
                gestionarMenu(menu); // Llama al método para gestionar la opción seleccionada.
            } catch (NumberFormatException e) {
                // Captura errores si el usuario introduce algo que no sea un número.
                System.err.println("Error de formato de menu, introducelo de nuevo");
            }
        } while (menu != 5); // El bucle se ejecuta hasta que el usuario elige la opción de salir.
    }

    /* Método para ejecutar las acciones correspondientes a cada opción del menú */
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> ticket.venderTicket(); // Generar y añadir un ticket al final de la cola.
            case 2 -> ticket.llamarCliente(); // Atender al próximo cliente en la cola.
            case 3 -> ticket.cancelarVenta(); // Cancelar la última venta realizada.
            case 4 -> ticket.mostrarCola(); // Mostrar todos los tickets en la cola.
            case 5 -> {
                System.out.println("Saliendo del programa ...");
                entrada.close(); // Cierra el objeto Scanner antes de salir.
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
        }
    }
}