Introducción

En este tema, exploraremos dos estructuras de datos fundamentales en Java: las colas (Queue) y las colas dobles (Deque). Estas estructuras son esenciales para manejar datos en escenarios donde el orden de procesamiento es crucial, como en sistemas de colas de tareas, algoritmos de búsqueda y más.

Cola (Queue)

Una cola es una estructura de datos que sigue el principio FIFO (First In, First Out), es decir, el primer elemento en entrar es el primero en salir. En Java, la interfaz Queue es parte del paquete java.util y tiene varias implementaciones, como LinkedList y PriorityQueue.

Métodos Principales de Queue

Método	Descripción
`add(e)`	Inserta el elemento especificado en la cola. Lanza una excepción si falla.
`offer(e)`	Inserta el elemento especificado en la cola. Devuelve `false` si falla.
`remove()`	Elimina y devuelve el primer elemento de la cola. Lanza una excepción si la cola está vacía.
`poll()`	Elimina y devuelve el primer elemento de la cola. Devuelve `null` si la cola está vacía.
`element()`	Devuelve el primer elemento de la cola sin eliminarlo. Lanza una excepción si la cola está vacía.
`peek()`	Devuelve el primer elemento de la cola sin eliminarlo. Devuelve `null` si la cola está vacía.

Ejemplo Práctico de Queue

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // Añadir elementos a la cola
        queue.add("Elemento 1");
        queue.add("Elemento 2");
        queue.add("Elemento 3");

        // Mostrar el primer elemento sin eliminarlo
        System.out.println("Primer elemento: " + queue.peek());

        // Eliminar y mostrar elementos de la cola
        while (!queue.isEmpty()) {
            System.out.println("Eliminando: " + queue.poll());
        }
    }
}

Explicación del Código

Creación de la Cola: Utilizamos LinkedList para implementar la interfaz Queue.
Añadir Elementos: Usamos el método add para insertar elementos en la cola.
Mostrar el Primer Elemento: Utilizamos peek para obtener el primer elemento sin eliminarlo.
Eliminar Elementos: Usamos poll en un bucle while para eliminar y mostrar cada elemento hasta que la cola esté vacía.

Cola Doble (Deque)

Una cola doble (Deque, Double-Ended Queue) es una estructura de datos que permite la inserción y eliminación de elementos en ambos extremos. La interfaz Deque también es parte del paquete java.util y tiene implementaciones como ArrayDeque y LinkedList.

Métodos Principales de Deque

Método	Descripción
`addFirst(e)`	Inserta el elemento especificado al inicio de la deque.
`addLast(e)`	Inserta el elemento especificado al final de la deque.
`offerFirst(e)`	Inserta el elemento especificado al inicio de la deque. Devuelve `false` si falla.
`offerLast(e)`	Inserta el elemento especificado al final de la deque. Devuelve `false` si falla.
`removeFirst()`	Elimina y devuelve el primer elemento de la deque. Lanza una excepción si la deque está vacía.
`removeLast()`	Elimina y devuelve el último elemento de la deque. Lanza una excepción si la deque está vacía.
`pollFirst()`	Elimina y devuelve el primer elemento de la deque. Devuelve `null` si la deque está vacía.
`pollLast()`	Elimina y devuelve el último elemento de la deque. Devuelve `null` si la deque está vacía.
`getFirst()`	Devuelve el primer elemento de la deque sin eliminarlo. Lanza una excepción si la deque está vacía.
`getLast()`	Devuelve el último elemento de la deque sin eliminarlo. Lanza una excepción si la deque está vacía.
`peekFirst()`	Devuelve el primer elemento de la deque sin eliminarlo. Devuelve `null` si la deque está vacía.
`peekLast()`	Devuelve el último elemento de la deque sin eliminarlo. Devuelve `null` si la deque está vacía.

Ejemplo Práctico de Deque

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();

        // Añadir elementos al inicio y al final
        deque.addFirst("Elemento 1");
        deque.addLast("Elemento 2");
        deque.addFirst("Elemento 3");

        // Mostrar el primer y último elemento sin eliminarlos
        System.out.println("Primer elemento: " + deque.peekFirst());
        System.out.println("Último elemento: " + deque.peekLast());

        // Eliminar y mostrar elementos de la deque
        while (!deque.isEmpty()) {
            System.out.println("Eliminando del inicio: " + deque.pollFirst());
        }
    }
}

Explicación del Código

Creación de la Deque: Utilizamos ArrayDeque para implementar la interfaz Deque.
Añadir Elementos: Usamos addFirst y addLast para insertar elementos al inicio y al final de la deque.
Mostrar Elementos: Utilizamos peekFirst y peekLast para obtener el primer y último elemento sin eliminarlos.
Eliminar Elementos: Usamos pollFirst en un bucle while para eliminar y mostrar cada elemento desde el inicio hasta que la deque esté vacía.

Ejercicios Prácticos

Ejercicio 1: Implementar una Cola de Tareas

Crea una clase TaskQueue que utilice una Queue para manejar una lista de tareas. La clase debe tener métodos para añadir tareas, obtener la siguiente tarea y verificar si la cola está vacía.

import java.util.LinkedList;
import java.util.Queue;

public class TaskQueue {
    private Queue<String> tasks;

    public TaskQueue() {
        tasks = new LinkedList<>();
    }

    public void addTask(String task) {
        tasks.add(task);
    }

    public String getNextTask() {
        return tasks.poll();
    }

    public boolean isEmpty() {
        return tasks.isEmpty();
    }

    public static void main(String[] args) {
        TaskQueue taskQueue = new TaskQueue();
        taskQueue.addTask("Tarea 1");
        taskQueue.addTask("Tarea 2");
        taskQueue.addTask("Tarea 3");

        while (!taskQueue.isEmpty()) {
            System.out.println("Procesando: " + taskQueue.getNextTask());
        }
    }
}

Ejercicio 2: Implementar una Deque de Números

Crea una clase NumberDeque que utilice una Deque para manejar una lista de números enteros. La clase debe tener métodos para añadir números al inicio y al final, obtener el primer y último número, y eliminar números del inicio y del final.

import java.util.ArrayDeque;
import java.util.Deque;

public class NumberDeque {
    private Deque<Integer> numbers;

    public NumberDeque() {
        numbers = new ArrayDeque<>();
    }

    public void addFirst(int number) {
        numbers.addFirst(number);
    }

    public void addLast(int number) {
        numbers.addLast(number);
    }

    public Integer getFirst() {
        return numbers.peekFirst();
    }

    public Integer getLast() {
        return numbers.peekLast();
    }

    public Integer removeFirst() {
        return numbers.pollFirst();
    }

    public Integer removeLast() {
        return numbers.pollLast();
    }

    public static void main(String[] args) {
        NumberDeque numberDeque = new NumberDeque();
        numberDeque.addFirst(1);
        numberDeque.addLast(2);
        numberDeque.addFirst(3);

        System.out.println("Primer número: " + numberDeque.getFirst());
        System.out.println("Último número: " + numberDeque.getLast());

        while (numberDeque.getFirst() != null) {
            System.out.println("Eliminando del inicio: " + numberDeque.removeFirst());
        }
    }
}

Conclusión

En esta sección, hemos aprendido sobre las colas (Queue) y las colas dobles (Deque) en Java. Estas estructuras de datos son fundamentales para manejar colecciones de elementos donde el orden de procesamiento es importante. Hemos visto ejemplos prácticos y ejercicios para reforzar los conceptos aprendidos. En el próximo módulo, exploraremos más estructuras de datos y colecciones en Java.

Cola y Deque

Introducción

Cola (Queue)

Métodos Principales de Queue

Ejemplo Práctico de Queue

Explicación del Código

Cola Doble (Deque)

Métodos Principales de Deque

Ejemplo Práctico de Deque

Explicación del Código

Ejercicios Prácticos

Ejercicio 1: Implementar una Cola de Tareas

Ejercicio 2: Implementar una Deque de Números

Conclusión

Curso de Programación en Java

Módulo 1: Introducción a Java

Módulo 2: Flujo de Control

Módulo 3: Programación Orientada a Objetos

Módulo 4: Programación Orientada a Objetos Avanzada

Módulo 5: Estructuras de Datos y Colecciones

Módulo 6: Manejo de Excepciones

Módulo 7: Entrada/Salida de Archivos

Módulo 8: Multihilo y Concurrencia

Módulo 9: Redes

Módulo 10: Temas Avanzados

Módulo 11: Frameworks y Librerías de Java

Módulo 12: Construcción de Aplicaciones del Mundo Real