Java Generic Linked Queue Implementation (FIFO)

Classified in Spanish

Written on November 21, 2025 in English with a size of 8.2 KB

Java LinkedQueue Implementation (Generic)

This document presents the source code for a generic LinkedQueue class in Java. This implementation uses a singly linked list structure, adheres to the FIFO (First-In, First-Out) principle, and implements the Iterable interface.


package org.mp.repaso;

import java.util.Iterator; import java.util.NoSuchElementException;

public class LinkedQueue<T> implements Iterable<T> {

<span style="color:#ba2da2">private int</span> N; <span style="color:rgb(0,132,0)">// Tamaño de la cola</span>
<span style="color:rgb(186,45,162)">private</span> Node&lt;T&gt; primero; <span style="color:rgb(0,132,0)">// Primer elemento de la cola (Head)</span>
<span style="color:rgb(186,45,162)">private</span> Node&lt;T&gt; ultimo; <span style="color:rgb(0,132,0)">// Último elemento de la cola (Tail)</span>

Node Inner Class


    private class Node<T> {
        private T element;
        private Node<T> next;

    <span style="color:rgb(186,45,162)">public</span> Node(T e) {
        element = e;
        next = <span style="color:rgb(186,45,162)">null</span>;
    }

    <span style="color:rgb(186,45,162)">public</span> Node(T e, Node&lt;T&gt; n) {
        element = e;
        next = n;
    }
}

Constructors


    public LinkedQueue() {
        primero = ultimo = null;
        N = 0;
    }

<span style="color:#ba2da2">public</span> LinkedQueue(T[] objects) {
    <span style="color:#ba2da2">for</span> (<span style="color:#ba2da2">int</span> i = <span style="color:#272ad8">0</span>; i &lt; objects.length; i++) {
        enqueue(objects[i]);
    }
}

Queue Utility Methods


    public boolean isEmpty() {
        return N == 0;
    }

<span style="color:rgb(186,45,162)">public void</span> clear() {
    primero = ultimo = <span style="color:rgb(186,45,162)">null</span>;
    N = <span style="color:rgb(39,42,216)">0</span>;
}

<span style="color:rgb(186,45,162)">public int</span> size() {
    <span style="color:rgb(186,45,162)">return</span> N;
}

Enqueue Operation (Adding an Element)


    public void enqueue(T e) {
        Node<T> nuevo = new Node<T>(e);
        if (ultimo == null) {
            primero = ultimo = nuevo;
        } else {
            ultimo.next = nuevo;
            ultimo = nuevo;
        }
        N++;
    }

Dequeue Operation (Removing the First Element)


    public T dequeue() {
        if (isEmpty()) throw new NoSuchElementException ("La cola está vacía");

    T aux = primero.element;
    primero = primero.next;
    N--;
    <span style="color:#ba2da2">return</span> aux;
}

Accessing the First Element (getFirst)


/**
 * Devuelve el primer elemento de la cola.
 * @return el primer elemento de la cola
 * @throws NoSuchElementException si la cola está vacía
 */
    public T getFirst() {
        if (isEmpty()) throw new NoSuchElementException("La cola está vacía");
        return primero.element;
    }

String Representation (toString)


/**
 * Devuelve una representación de la cola.
 * @return la secuencia de elementos contenidos en la cola en orden FIFO
 */
    public String toString() {
        Node<T> temp = primero; // Creamos el nodo temporal para recorrer
        String s = "[";
        while (temp != null) {
            s += temp.element;
            temp = temp.next;
            if (temp != null) {
                s += ", ";
            }
        }
        return s + "]";
    }

Iterator Implementation


/**
 * Devuelve un iterador para esta cola que permite iterar sobre los elementos en orden FIFO.
 * @return un iterador para esta cola que permite iterar sobre los elementos en orden FIFO
 */
    public Iterator<T> iterator() {
        return new LinkedQueueIterator();
    }

LinkedQueueIterator Inner Class


/**
 * Clase privada LinkedQueueIterator
 */
    private class LinkedQueueIterator implements Iterator<T> {

/**


Nodo temporal
*/
private Node<T> temp;

/**


Constructor por defecto, que establece temp como
el primer nodo (frente de la cola)
*/
public LinkedQueueIterator() {
temp = primero;
}

/**


Comprueba si tiene siguiente.
@return true si tiene siguiente, false en caso contrario
*/
public boolean hasNext() {
return temp != null;
}

/**


Devuelve el elemento siguiente.
@return el elemento siguiente
@throws NoSuchElementException si no hay elementos en la cola
*/
public T next() {
if (temp == null) throw new NoSuchElementException("La cola está vacía");
T aux = temp.element;
temp = temp.next;
return aux;
}

/**


Remove. (Operación No Soportada)
@throws UnsupportedOperationException
*/
public void remove() {
throw new UnsupportedOperationException();
}
}
}

Related entries:

Tags: