Cola de Java – Cola en Java

Java Queue es una interfaz disponible en el paquete java.util y extiende la interfaz java.util.Collection. Al igual que Java List, Java Queue es una colección de elementos ordenados (u objetos), pero realiza operaciones de inserción y eliminación de manera diferente. Podemos usar Queue para almacenar elementos antes de procesar esos elementos.

Java Queue

En esta sección, discutiremos algunos puntos importantes sobre Java Queue:

• La interfaz java.util.Queue es un subtipo de la interfaz java.util.Collection.
• Al igual que una cola del mundo real (por ejemplo, en un banco o en un cajero automático), Queue inserta elementos al final de la cola y los elimina desde el principio de la cola.
• Java Queue representa una lista ordenada de elementos.
• Java Queue sigue el orden FIFO para insertar y eliminar sus elementos. FIFO significa Primero en Entrar, Primero en Salir.
• Java Queue admite todos los métodos de la interfaz Collection.
• Las implementaciones de Queue más utilizadas son LinkedList, ArrayBlockingQueue y PriorityQueue.
• Las BlockingQueues no aceptan elementos nulos. Si realizamos alguna operación relacionada con null, lanzará NullPointerException.
• Las BlockingQueues se utilizan para implementar aplicaciones basadas en Productor/Consumidor.
• Las BlockingQueues son seguras para subprocesos.
• Todas las colas disponibles en el paquete java.util son colas no acotadas, mientras que las colas disponibles en el paquete java.util.concurrent son colas acotadas.
• Todas las deque no son seguras para subprocesos.
• ConcurrentLinkedQueue es una cola no acotada y segura para subprocesos basada en nodos enlazados.
• Todas las colas admiten la inserción en la cola y la eliminación en la cabeza de la cola, excepto las deques.
• Las deques son colas, pero admiten la inserción y eliminación de elementos en ambos extremos.

Diagrama de Clase de la Clase Queue de Java

La interfaz Java Queue extiende la interfaz Collection. La interfaz Collection extiende la interfaz Iterable. Algunas de las implementaciones de colas de uso frecuente son LinkedList, PriorityQueue, ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, etc. AbstractQueue proporciona una implementación esquelética de la interfaz Queue para reducir el esfuerzo en la implementación de colas.

Métodos de la Clase Queue de Java

En esta sección, discutiremos algunos de los métodos útiles y frecuentemente utilizados de la interfaz Queue de Java:

1. int size(): para obtener el número de elementos en el conjunto.
2. boolean isEmpty(): para verificar si el conjunto está vacío o no.
3. boolean contains(Object o): Devuelve true si este conjunto contiene el elemento especificado.
4. Iterator iterator(): Devuelve un iterador sobre los elementos de este conjunto. Los elementos se devuelven en ningún orden en particular.
5. boolean removeAll(Collection c): Elimina de este conjunto todos sus elementos que están contenidos en la colección especificada (operación opcional).
6. boolean retainAll(Collection c): Retiene solo los elementos de este conjunto que están contenidos en la colección especificada (operación opcional).
7. void clear(): Elimina todos los elementos del conjunto.
8. E remove(): Retrieves and removes the head of this queue.
9. E poll(): Retrieves and removes the head of this queue, or returns null if this queue is empty.
10. E peek(): Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
11. boolean offer(E e): Inserta el elemento especificado en esta cola si es posible hacerlo inmediatamente sin violar las restricciones de capacidad.
12. E element(): Retrieves, but does not remove, the head of this queue.
13. boolean add(E e): Inserta el elemento especificado en esta cola si es posible hacerlo inmediatamente sin violar las restricciones de capacidad, devolviendo true al tener éxito y lanzando un IllegalStateException si actualmente no hay espacio disponible.
14. Object[] toArray(): Devuelve un array que contiene todos los elementos de este conjunto. Si este conjunto garantiza algún orden en cómo se devuelven sus elementos por su iterador, este método debe devolver los elementos en el mismo orden.

Conceptos Básicos de Colas en Java

Como Java Queue extiende Java Collection, también admite todas las operaciones de la interfaz Collection. Vamos a explorar algunas operaciones simples en el siguiente ejemplo:

package com.journaldev.queue;
import java.util.*;

public class QueueExample {
   public static void main(String[] args) {
		
	Queue queue = new LinkedList<>();
	queue.add("one");
	queue.add("two");
	queue.add("three");
	queue.add("four");
	System.out.println(queue);
		
	queue.remove("three");
	System.out.println(queue);
	System.out.println("Queue Size: " + queue.size());
	System.out.println("Queue Contains element 'two' or not? : " + queue.contains("two"));

	 // Para vaciar la cola

	queue.clear();
   }
}

Salida:

[one, two, three, four]
[one, two, four]
Queue Size: 3
Queue Contains element 'two' or not? : true

Java Array a Queue

Aquí podemos explorar cómo convertir un array de Java a una Queue utilizando el método “Collections.addAll()” con un ejemplo simple.

import java.util.*;

public class ArrayToQueue {
    public static void main(String[] args) {
		
	String nums[] = {"one","two","three","four","five"};
	Queue<String> queue = new LinkedList<>();
	Collections.addAll(queue, nums);
	System.out.println(queue);
   }
}

Salida: Cuando ejecutamos el programa anterior, obtendremos la siguiente salida:

[one, two, three, four, five]

Queue de Java a Array

Aquí exploraremos cómo convertir una Queue de Java a un Array de Java utilizando “toArray()” con un ejemplo simple.

import java.util.*;

public class QueueToArray {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
	queue.add("two");
	queue.add("three");
	queue.add("four");
	queue.add("five");
		
	String strArray[] = queue.toArray(new String[queue.size()]);
	System.out.println(Arrays.toString(strArray)); 

   }
}

Salida: Cuando ejecutamos el programa anterior, obtendremos la siguiente salida:

[one, two, three, four, five]

Operaciones Comunes de la Queue de Java

La Queue de Java admite todas las operaciones admitidas por la interfaz Collection y algunas operaciones adicionales. Admite casi todas las operaciones en dos formas.

• Uno conjunto de operaciones arroja una excepción si la operación falla.
• Otro conjunto de operaciones devuelve un valor especial si la operación falla.

La siguiente tabla explica brevemente todas las operaciones comunes de una cola.

Abordaremos cada operación en detalle con algunos ejemplos útiles en las secciones siguientes.

Operaciones de Inserción en Colas de Java

En esta sección, discutiremos la operación de inserción en colas de Java en detalle con algunos ejemplos útiles. Si esta operación se realiza con éxito, devuelve el valor “true”. Como sabemos, la cola admite la operación de inserción en dos formas:

• Queue.add(e):
  Arroja una excepción si la operación falla.- Queue.offer(e):
  Devuelve un valor especial si la operación falla.

NOTA:- Aquí, el valor especial puede ser “false” o “null”

Operación add() de la Cola

La operación add() se utiliza para insertar un nuevo elemento en la cola. Si realiza la operación de inserción con éxito, devuelve el valor “true”. De lo contrario, arroja java.lang.IllegalStateException. Desarrollemos un ejemplo simple para demostrar esta funcionalidad.

import java.util.concurrent.*;

public class QueueAddOperation {
   public static void main(String[] args) {
		
	BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

	System.out.println(queue.add("one"));
	System.out.println(queue.add("two"));
	System.out.println(queue);
	System.out.println(queue.add("three"));
	System.out.println(queue);
   }
}

Salida:- Cuando ejecutamos el programa anterior, obtendremos la siguiente salida:

true
true
[one, two]
Exception in thread "main" java.lang.IllegalStateException: Queue full

Dado que nuestra cola está limitada a dos elementos, cuando intentamos agregar un tercer elemento utilizando BlockingQueue.add(), se genera una excepción como se muestra anteriormente.

Operación offer() de la cola

La operación offer() se utiliza para insertar un nuevo elemento en la cola. Si realiza la operación de inserción con éxito, devuelve el valor “true”. De lo contrario, devuelve el valor “false”. Desarrollemos un ejemplo simple para demostrar esta funcionalidad.

import java.util.concurrent.*;

public class QueueOfferOperation {
   public static void main(String[] args) {
		
	BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

	System.out.println(queue.offer("one"));
	System.out.println(queue.offer("two"));
	System.out.println(queue);
	System.out.println(queue.offer("three"));
	System.out.println(queue);
   }
}

Salida:- Cuando ejecutamos el programa anterior, obtendremos la siguiente salida:

true
true
[one, two]
false
[one, two]

Dado que nuestra cola está limitada a dos elementos, cuando intentamos agregar un tercer elemento utilizando la operación BlockingQueue.offer(), devuelve el valor “false” como se muestra anteriormente.

Operaciones de eliminación de la cola en Java

En esta sección, discutiremos detalladamente las operaciones de eliminación de la cola en Java con algunos ejemplos útiles. Las operaciones de eliminación devuelven el elemento principal de la cola si se realizan con éxito. Como sabemos, la cola admite la operación de eliminación en dos formas:

• Queue.remove():
  Lanza una excepción si la operación falla. – Queue.poll():
  Devuelve un valor especial si la operación falla.

NOTA:- Aquí el valor especial puede ser “false” o “null”

Operación de eliminación de la cola

La operación remove() se utiliza para eliminar un elemento de la cabeza de la cola. Si realiza la operación de eliminación con éxito, devuelve el elemento de la cabeza de la cola. De lo contrario, arroja java.util.NoSuchElementException. Desarrollemos un ejemplo simple para demostrar esta funcionalidad.

import java.util.*;

public class QueueRemoveOperation 
{
   public static void main(String[] args) 
   {		
	Queue<String> queue = new LinkedList<>();
	queue.offer("one");
	queue.offer("two");		
	System.out.println(queue);		
	System.out.println(queue.remove());
	System.out.println(queue.remove());		
	System.out.println(queue.remove());		
   }
}

Salida:- Cuando ejecutamos el programa anterior, obtenemos la siguiente salida:

[one, two]
one
two
Exception in thread "main" java.util.NoSuchElementException

Dado que nuestra cola tiene solo dos elementos, cuando intentamos llamar al método remove() por tercera vez, arroja una excepción como se muestra arriba. NOTA:- Queue.remove(element) se utiliza para eliminar un elemento específico de la cola. Si realiza la operación de eliminación con éxito, devuelve el valor “true”. De lo contrario, devuelve el valor “false”.

Operación de cola poll()

La operación poll() se utiliza para eliminar un elemento de la cabeza de la cola. Si realiza la operación de eliminación con éxito, devuelve el elemento de la cabeza de la cola. De lo contrario, devuelve el valor “null”. Desarrollemos un ejemplo simple para demostrar esta funcionalidad.

import java.util.*;

public class QueuePollOperation 
{
   public static void main(String[] args) 
   {		
	Queue<String> queue = new LinkedList<>();
	queue.offer("one");
	queue.offer("two");		
	System.out.println(queue);		
	System.out.println(queue.poll());
	System.out.println(queue.poll());		
	System.out.println(queue.poll());		
   }
}

Salida:- Cuando ejecutamos el programa anterior, obtendremos la siguiente salida:

[one, two]
one
two
null

Como nuestra cola tiene solo dos elementos, cuando intentamos llamar al método poll() por tercera vez, devuelve un valor nulo como se muestra arriba.

Operaciones de Examen de la Cola Java

En esta sección, discutiremos las operaciones de examen de la cola en Java en detalle con algunos ejemplos útiles. Si esta operación se realiza con éxito, devuelve el elemento principal de la cola sin eliminarlo. Como sabemos, la cola admite la operación de examen en dos formas:

• Queue.element():
  Lanza una excepción si la operación falla.- Queue.peek():
  Devuelve un valor especial si la operación falla.

NOTA:- Aquí, el valor especial puede ser “false” o “null”

Operación Queue element()

La operación element() se utiliza para recuperar un elemento de la cabeza de la cola, sin eliminarlo. Si realiza la operación de examen con éxito, devuelve el elemento principal de la cola. De lo contrario, lanza java.util.NoSuchElementException. Desarrollemos un ejemplo simple para demostrar esta funcionalidad.

import java.util.*;

public class QueueElementOperation {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
		
	System.out.println(queue.element());
	System.out.println(queue);
	queue.clear();
	System.out.println(queue.element());
   }
}

Salida:- Cuando ejecutamos el programa anterior, obtendremos la siguiente salida:

one
[one]
Exception in thread "main" java.util.NoSuchElementException

Si intentamos llamar al método `element()` en una cola vacía, lanzará una excepción como se muestra arriba.

Operación de peek() en la cola

La operación `peek()` se utiliza para recuperar un elemento de la cabeza de la cola, sin eliminarlo. Si realiza la operación de examen con éxito, devuelve el elemento de la cabeza de la cola. De lo contrario, devuelve un valor nulo. Desarrollemos un ejemplo simple para demostrar esta funcionalidad.

import java.util.*;

public class QueuePeekOperation {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
		
	System.out.println(queue.peek());
	System.out.println(queue);
	queue.clear();
	System.out.println(queue.peek());
   }
}

Salida:- Cuando ejecutamos el programa anterior, obtendremos la siguiente salida:

one
[one]
null

Si intentamos llamar al método `peek()` en una cola vacía, devuelve un valor nulo, pero NO lanza una excepción como se muestra arriba.

Categorías de Colas en Java

En Java, podemos encontrar muchas implementaciones de colas. Podemos categorizarlas ampliamente en los siguientes dos tipos

• Colas Acotadas
• Colas No Acotadas

Colas acotadas son colas que están limitadas por capacidad, lo que significa que debemos proporcionar el tamaño máximo de la cola en el momento de la creación. Por ejemplo, ArrayBlockingQueue (ver ejemplo anterior). Colas no acotadas son colas que NO están limitadas por capacidad, lo que significa que no debemos proporcionar el tamaño de la cola. Por ejemplo, LinkedList (ver ejemplo anterior). Todas las colas disponibles en el paquete java.util son colas no acotadas y las colas disponibles en el paquete java.util.concurrent son colas acotadas. En otras palabras, podemos clasificarlas ampliamente en los siguientes dos tipos:

• Colas de Bloqueo
• Colas No Bloqueo

Todas las colas que implementan la interfaz BlockingQueue son BlockingQueues y el resto son colas No Bloqueo. Las BlockingQueues se bloquean hasta que terminan su tarea o agotan el tiempo, pero las Non-BlockingQueues no lo hacen. Algunas colas son Deques y algunas colas son PriorityQueues.

Operaciones de BlockingQueue

Además de las dos formas de operaciones de la cola, BlockingQueue admite otras dos formas, como se muestra a continuación.

Algunas operaciones se bloquean hasta que terminan su tarea y otras se bloquean hasta que agotan el tiempo. Eso es todo en un rápido resumen sobre Colas en Java. Espero que estos ejemplos de Colas en Java te ayuden a empezar con la programación de colecciones de colas. Por favor, déjame un comentario si te gustan mis tutoriales o si tienes alguna sugerencia o problema o errores tipográficos. Gracias.