Interfaz de cola en Java

La interfaz Queue está presente en el paquete java.util y amplía la interfaz Collection que se utiliza para contener los elementos que se van a procesar en orden FIFO (primero en entrar, primero en salir). Es una lista ordenada de objetos cuyo uso se limita a insertar elementos al final de la lista y eliminar elementos al principio de la lista, (es decir), sigue el principio FIFO o First-In-First-Out.

Al ser una interfaz, la cola necesita una clase concreta para la declaración y las clases más comunes son PriorityQueue y LinkedList en Java. Tenga en cuenta que ninguna de estas implementaciones es segura para subprocesos. PriorityBlockingQueue es una implementación alternativa si se necesita la implementación segura para subprocesos.

Declaración: la interfaz de cola se declara como:

public interface Queue extends Collection  

Creación de objetos de cola: como Queue es una interfaz , no se pueden crear objetos del tipo cola. Siempre necesitamos una clase que amplíe esta lista para crear un objeto. Y también, después de la introducción de Generics en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en la Cola. Esta cola de tipo seguro se puede definir como:

// Obj is the type of the object to be stored in Queue 
Queue<Obj> queue = new PriorityQueue<Obj> ();  

Ejemplo: cola

// Java program to demonstrate a Queue
  
import java.util.LinkedList;
import java.util.Queue;
  
public class QueueExample {
  
    public static void main(String[] args)
    {
        Queue<Integer> q
            = new LinkedList<>();
  
        // Adds elements {0, 1, 2, 3, 4} to
        // the queue
        for (int i = 0; i < 5; i++)
            q.add(i);
  
        // Display contents of the queue.
        System.out.println("Elements of queue "
                           + q);
  
        // To remove the head of queue.
        int removedele = q.remove();
        System.out.println("removed element-"
                           + removedele);
  
        System.out.println(q);
  
        // To view the head of queue
        int head = q.peek();
        System.out.println("head of queue-"
                           + head);
  
        // Rest all methods of collection
        // interface like size and contains
        // can be used with this
        // implementation.
        int size = q.size();
        System.out.println("Size of queue-"
                           + size);
    }
}

Elements of queue [0, 1, 2, 3, 4]
removed element-0
[1, 2, 3, 4]
head of queue-1
Size of queue-4

Operaciones en la interfaz de cola

Veamos cómo realizar algunas operaciones de uso frecuente en la cola usando la clase Priority Queue .

1. Agregar elementos: para agregar un elemento en una cola, podemos usar el método add() . El pedido de inserción no se conserva en PriorityQueue. Los elementos se almacenan según el orden de prioridad que es ascendente por defecto. 

Ejemplo

// Java program to add elements
// to a Queue
  
import java.util.*;
  
public class GFG {
  
    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();
  
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
  
        System.out.println(pq);
    }
}

[For, Geeks, Geeks]

2. Eliminación de elementos: para eliminar un elemento de una cola, podemos usar el método remove(). Si hay varios de estos objetos, se elimina la primera aparición del objeto. Aparte de eso, el método poll() también se usa para quitar la cabeza y devolverla. 

Ejemplo

// Java program to remove elements
// from a Queue
  
import java.util.*;
  
public class GFG {
  
    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();
  
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
  
        System.out.println("Initial Queue " + pq);
  
        pq.remove("Geeks");
  
        System.out.println("After Remove " + pq);
  
        System.out.println("Poll Method " + pq.poll());
  
        System.out.println("Final Queue " + pq);
    }
}

Initial Queue [For, Geeks, Geeks]
After Remove [For, Geeks]
Poll Method For
Final Queue [Geeks]

3. Iteración de la cola: hay varias formas de iterar a través de la cola. La forma más famosa es convertir la cola en una array y atravesarla usando el bucle for. Sin embargo, la cola también tiene un iterador incorporado que se puede usar para iterar a través de la cola. 

Ejemplo

// Java program to iterate elements
// to a Queue
  
import java.util.*;
  
public class GFG {
  
    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();
  
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
  
        Iterator iterator = pq.iterator();
  
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

For Geeks Geeks

Características de una cola: Las siguientes son las características de la cola:

• La Cola se usa para insertar elementos al final de la cola y los elimina del principio de la cola. Sigue el concepto FIFO.
• Java Queue admite todos los métodos de la interfaz de recopilación, incluida la inserción, la eliminación, etc.
• LinkedList , ArrayBlockingQueue y PriorityQueue son las implementaciones más utilizadas.
• Si se realiza alguna operación nula en BlockingQueues, se lanza NullPointerException.
• Las colas que están disponibles en el paquete java.util son colas ilimitadas.
• Las colas que están disponibles en el paquete java.util.concurrent son las colas limitadas.
• Todas las colas, excepto Deques, admiten la inserción y eliminación en la cola y la cabeza de la cola, respectivamente. La inserción y extracción del elemento de soporte Deques en ambos extremos. 

Clases que implementan la interfaz de cola:

1. PriorityQueue: la clase PriorityQueue que se implementa en el marco de la colección nos proporciona una forma de procesar los objetos en función de la prioridad. Se sabe que una cola sigue el algoritmo First-In-First-Out, pero a veces se necesita procesar los elementos de la cola de acuerdo con la prioridad, ahí es cuando entra en juego PriorityQueue. Veamos cómo crear un objeto de cola usando esta clase.

Ejemplo

// Java program to demonstrate the
// creation of queue object using the
// PriorityQueue class
  
import java.util.*;
  
class GfG {
  
    public static void main(String args[])
    {
        // Creating empty priority queue
        Queue<Integer> pQueue
            = new PriorityQueue<Integer>();
  
        // Adding items to the pQueue
        // using add()
        pQueue.add(10);
        pQueue.add(20);
        pQueue.add(15);
  
        // Printing the top element of
        // the PriorityQueue
        System.out.println(pQueue.peek());
  
        // Printing the top element and removing it
        // from the PriorityQueue container
        System.out.println(pQueue.poll());
  
        // Printing the top element again
        System.out.println(pQueue.peek());
    }
}

10
10
15

2. LinkedList: LinkedList es una clase que se implementa en el marco de la colección que implementa inherentemente la estructura de datos de la lista vinculada . Es una estructura de datos lineal donde los elementos no se almacenan en ubicaciones contiguas y cada elemento es un objeto separado con una parte de datos y una parte de dirección. Los elementos se vinculan mediante punteros y direcciones. Cada elemento se conoce como un Node. Debido a la dinámica y facilidad de las inserciones y eliminaciones, son preferibles a las arrays o colas. Veamos cómo crear un objeto de cola usando esta clase.

Ejemplo

// Java program to demonstrate the
// creation of queue object using the
// LinkedList class
  
import java.util.*;
  
class GfG {
  
    public static void main(String args[])
    {
        // Creating empty LinkedList
        Queue<Integer> ll
            = new LinkedList<Integer>();
  
        // Adding items to the ll
        // using add()
        ll.add(10);
        ll.add(20);
        ll.add(15);
  
        // Printing the top element of
        // the LinkedList
        System.out.println(ll.peek());
  
        // Printing the top element and removing it
        // from the LinkedList container
        System.out.println(ll.poll());
  
        // Printing the top element again
        System.out.println(ll.peek());
    }
}

10
10
20

3. PriorityBlockingQueue: Cabe señalar que ambas implementaciones, PriorityQueue y LinkedList, no son seguras para subprocesos. PriorityBlockingQueue es una implementación alternativa si se necesita una implementación segura para subprocesos. PriorityBlockingQueue es una cola de bloqueo ilimitada que utiliza las mismas reglas de ordenación que la clase PriorityQueue y proporciona operaciones de recuperación de bloqueo. 
Dado que no tiene límites, la adición de elementos a veces puede fallar debido al agotamiento de los recursos, lo que genera OutOfMemoryError . Veamos cómo crear un objeto de cola usando esta clase.

Ejemplo

// Java program to demonstrate the
// creation of queue object using the
// PriorityBlockingQueue class
  
import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;
  
class GfG {
    public static void main(String args[])
    {
        // Creating empty priority
        // blocking queue
        Queue<Integer> pbq
            = new PriorityBlockingQueue<Integer>();
  
        // Adding items to the pbq
        // using add()
        pbq.add(10);
        pbq.add(20);
        pbq.add(15);
  
        // Printing the top element of
        // the PriorityBlockingQueue
        System.out.println(pbq.peek());
  
        // Printing the top element and
        // removing it from the
        // PriorityBlockingQueue
        System.out.println(pbq.poll());
  
        // Printing the top element again
        System.out.println(pbq.peek());
    }
}

10
10
15

Métodos de interfaz de cola

La interfaz de cola hereda todos los métodos presentes en la interfaz de colecciones mientras implementa los siguientes métodos: