Cola (Queue) en Java desde cero - Estructura de Datos en JAVA

 Cola en Java - Estructura de Datos ☕

El TDA (Tipo de Dato Abstracto) de una cola es una estructura fundamental en programación que sigue el principio de "primero en entrar, primero en salir" (FIFO, por sus siglas en inglés: First-In, First-Out). En este artículo, exploraremos cómo implementar una cola desde cero en Java, brindando una visión completa del TDA y sus funcionalidades principales.

¿Cómo funciona una cola en java?🤔

Su funcionamiento tiene relación con una fila o cola por ejemplo, imaginemos que vamos a un banco, para poder ser atendidos en el banco tenemos que hacer una fila, la primera persona que llegue en la fila debe de ser la primera en ser atendida, luego la segunda persona que llegó a la fila y así sucesivamente, esta es la forma en la que funciona una Cola o Queue en JAVA. 👨‍💻
Para empezar vamos a crear una clase a la cual la llamaremos Nodo, con esta clase vamos a lograr hacer las uniones con otros Nodos de tal manera que tengamos varios elementos "unidos", para ello le definimos dos atributos Object dato, (representa el dato que se va a almacenar, usando Object podemos guardar un int, char, String, Estudiante, lo que quieras se puede guardar) y otro atributo el cual será de tipo Nodo llamado siguiente (hace referencia al elemento siguiente).

Clase Nodo

  package Cola;

/*Nodo para la Cola Queu*/
public class Nodo {

    private Object dato;
    private Nodo siguiente;

    public Nodo(Object dato, Nodo siguiente) {
        this.dato = dato;
        this.siguiente = siguiente;
    }

    
    public Object getDato() {
        return dato;
    }

    public void setDato(Object dato) {
        this.dato = dato;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }

    @Override
    public String toString() {
        return "Nodo{" + "dato=" + dato + ", siguiente=" + siguiente + '}';
    }
    
}
  
  

Una vez tengamos la clase Nodo, vamos a empezar a crear la Clase Cola, con la que vamos a estar creando los métodos vacia(), agregar(), encolar(), desencolar(), eliminar(), imprimir(), etc.
Para cada método vamos a estar creando la lógica necesaria para el correcto funcionamiento.

Clase Cola

  package Cola;

import Pilas.Pila;

public class Cola {

    private Nodo inicio;
    private Nodo fin;
    private int cantidad; // hace referencia a la cantidad de elemento

    public Cola() {
        this.inicio = null;
        this.fin = null;
        this.cantidad = 0;
    }

    public boolean vacia() {
        return inicio == null && fin == null;
    }

    //para agregar en la cola o de ultimo
    public void encolar(Object dato) {
        if (vacia()) {
            inicio = fin = new Nodo(dato, null);
        } else {
            Nodo nuevo = new Nodo(dato, null);
            fin.setSiguiente(nuevo);
            fin = nuevo;
        }
        cantidad++;
    }

    public void desencolar() {
        if (!vacia()) {
            if (inicio == fin) {
                inicio = fin = null;
            } else {
                inicio = inicio.getSiguiente();
            }
            cantidad--;
        }
    }

    public void eliminar(Object dato) {
        if (!vacia()) {
            Cola aux = new Cola();
            while (!vacia()) {
                if (!inicio.getDato().equals(dato)) {
                    aux.encolar(inicio.getDato());
                }
                desencolar();
            }
            inicio = aux.getInicio();
            fin = aux.getFin();
            cantidad = aux.getCantidad();
        }
    }

    public void ejercicio1(int x) {
        if (!vacia()) {
            boolean flag = false;
            // en la cola se saca el primero
            // y solo se agrega a lo último
            Cola aux = new Cola();
            while (!vacia()) {
                if ((int) (inicio.getDato()) == x) {
                    flag = true;
                }
                aux.encolar(inicio.getDato());
                desencolar();
            }

            if (!flag) {
                while (!aux.vacia()) {
                    encolar(aux.inicio.getDato());
                    aux.desencolar();
                }
                encolar(x);

            } else {
                encolar(x);
                while (!aux.vacia()) {
                    if ((int) (aux.inicio.getDato()) != x) {
                        encolar(aux.inicio.getDato());
                    }
                    aux.desencolar();
                }
            }
        }
    }


    public String mostrar() {
        String salida = "";
        if (!vacia()) {
            Nodo aux = inicio;
            while (aux != null) {
                salida += aux.getDato() + " ";
                aux = aux.getSiguiente();
            }
        }
        return salida;
    }

    //Getter and Setter
    public Nodo getInicio() {
        return inicio;
    }

    public void setInicio(Nodo inicio) {
        this.inicio = inicio;
    }

    public Nodo getFin() {
        return fin;
    }

    public void setFin(Nodo fin) {
        this.fin = fin;
    }

    public int getCantidad() {
        return cantidad;
    }

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

    @Override
    public String toString() {
        return "Cola{" + "inicio=" + inicio + ", fin=" + fin + ", cantidad=" + cantidad + '}';
    }

}
   
   

Una vez tengamos esto, nos vamos a dar cuenta que el código no es tan extenso en comparación con una lista simple, doble o circular, ya que la cola funciona como una lista, pero es restrictiva en los métodos, ya que solamente se agregan elementos al final de la cola.
Para usar lo que hemos creado anteriormente, podemos crear una clase Main para poder hacer uso de la Cola, usar todos los métodos que tiene y ver que funciona correctamente.

Main

  
package Cola;


public class Main {

    public static void main(String[] args) {
        Cola cola = new Cola();
        cola.encolar(3);
        cola.encolar(4);
        cola.encolar(5);
        cola.encolar(6);
        cola.encolar(3);
        cola.encolar(4);
        cola.encolar(5);
        cola.encolar(6);
        
        System.out.println(cola.mostrar());
        cola.eliminar(3);
        System.out.println(cola.mostrar());
        
    }
    
}

Esta implementación del TDA de una cola en Java proporciona una base sólida para utilizar colas en tus programas y aplicarlas en una variedad de situaciones 👨‍💻☕.