La interfaz de cola está presente en java.util paquete y extiende el Interfaz de colección se utiliza para contener los elementos que están a punto de ser procesados en orden FIFO (primero en entrar, primero en salir). Es una lista ordenada de objetos con su uso limitado a insertar elementos al final de la lista y eliminar elementos del inicio de la lista, (es decir), sigue el FIFO o el principio de primero en entrar, primero en salir.
ubuntu que comando
Al ser una interfaz, la cola necesita una clase concreta para la declaración y las clases más comunes son las Cola de prioridad y Lista enlazada en Java. Tenga en cuenta que ninguna de estas implementaciones es segura para subprocesos. Cola de bloqueo de prioridad 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>
Creando objetos de cola: Desde Cola es un interfaz , no se pueden crear objetos del tipo cola. Siempre necesitamos una clase que amplíe esta lista para poder crear un objeto. Y también, tras la introducción de Genéricos en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en la cola. Esta cola con seguridad de tipos se puede definir como:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
En Java, la interfaz Queue es un subtipo de la interfaz Collection y representa una colección de elementos en un orden específico. Sigue el principio de primero en entrar, primero en salir (FIFO), lo que significa que los elementos se recuperan en el orden en que se agregaron a la cola.
La interfaz Queue proporciona varios métodos para agregar, eliminar e inspeccionar elementos en la cola. Estos son algunos de los métodos más utilizados:
agregar (elemento): agrega un elemento al final de la cola. Si la cola está llena, genera una excepción.
oferta (elemento): agrega un elemento al final de la cola. Si la cola está llena, devuelve falso.
remove(): elimina y devuelve el elemento al principio de la cola. Si la cola está vacía, genera una excepción.
poll(): elimina y devuelve el elemento al principio de la cola. Si la cola está vacía, devuelve nulo.
elemento(): Devuelve el elemento al principio de la cola sin eliminarlo. Si la cola está vacía, genera una excepción.
peek(): Devuelve el elemento al principio de la cola sin eliminarlo. Si la cola está vacía, devuelve nulo.
La interfaz Queue está implementada por varias clases en Java, incluidas LinkedList, ArrayDeque y PriorityQueue. Cada una de estas clases proporciona diferentes implementaciones de la interfaz de cola, con diferentes características y características de rendimiento.
En general, la interfaz Queue es una herramienta útil para gestionar colecciones de elementos en un orden específico y se utiliza ampliamente en muchas aplicaciones e industrias diferentes.
Ejemplo:
Java
import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args) {> >Queue queue =>new> LinkedList();> >// add elements to the queue> >queue.add(>'apple'>);> >queue.add(>'banana'>);> >queue.add(>'cherry'>);> >// print the queue> >System.out.println(>'Queue: '> + queue);> >// remove the element at the front of the queue> >String front = queue.remove();> >System.out.println(>'Removed element: '> + front);> >// print the updated queue> >System.out.println(>'Queue after removal: '> + queue);> >// add another element to the queue> >queue.add(>'date'>);> >// peek at the element at the front of the queue> >String peeked = queue.peek();> >System.out.println(>'Peeked element: '> + peeked);> >// print the updated queue> >System.out.println(>'Queue after peek: '> + queue);> >}> }> |
>
>Producción
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Ejemplo: Cola
Java
// Java program to demonstrate a Queue> import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args)> >{> >Queue 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);> >}> }> |
>
>Producción
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 el Clase de cola prioritaria .
1. Agregar elementos: Para agregar un elemento en una cola, podemos usar el método agregar () . El orden 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
// Java program to add elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >System.out.println(pq);> >}> }> |
>
>Producción
[For, Geeks, Geeks]>
2. Eliminación de elementos: Para eliminar un elemento de una cola, podemos usar el método eliminar(). Si hay varios objetos de este tipo, se elimina la primera aparición del objeto. Aparte de eso, el método poll() también se utiliza para quitar la cabeza y devolverla.
Ejemplo
Java
// Java program to remove elements> // from a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue 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);> >}> }> |
>
>Producción
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Iterando la cola: Hay varias formas de recorrer la cola. La forma más famosa es convertir la cola en una matriz y recorrerla utilizando el bucle for. Sin embargo, la cola también tiene un iterador incorporado que se puede utilizar para iterar a través de la cola.
Ejemplo
Java
// Java program to iterate elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >Iterator iterator = pq.iterator();> >while> (iterator.hasNext()) {> >System.out.print(iterator.next() +>' '>);> >}> >}> }> |
>
>Producción
For Geeks Geeks>
Características de una cola: Las siguientes son las características de la cola:
- La cola se utiliza para insertar elementos al final de la cola y eliminarlos del principio de la cola. Sigue el concepto FIFO.
- Java Queue admite todos los métodos de la interfaz de Colección, incluida la inserción, eliminación, etc.
- Lista enlazada , ArrayBlockingQueue y Cola de prioridad 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 colas limitadas.
- Todas las colas, excepto Deques, admiten la inserción y eliminación al final y al principio de la cola, respectivamente. Los Deques soportan la inserción y extracción del elemento por ambos extremos.
Clases que implementan la interfaz de cola:
1. Cola de prioridad: La clase PriorityQueue que se implementa en el marco de la colección nos proporciona una forma de procesar los objetos según la prioridad. Se sabe que una cola sigue el algoritmo Primero en entrar, primero en salir, pero a veces es necesario procesar los elementos de la cola según la prioridad, es entonces cuando entra en juego PriorityQueue. Veamos cómo crear un objeto de cola usando esta clase.
Ejemplo
Java
// 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 pQueue> >=>new> PriorityQueue();> >// 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());> >}> }> |
>
>Producción
10 10 15>
2. Lista enlazada: LinkedList es una clase que se implementa en el marco de la colección que implementa inherentemente el Ejemplo
Java
// 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 ll> >=>new> LinkedList();> >// 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());> >}> }> |
>
>Producción
10 10 20>
3. Cola de bloqueo de prioridad: 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. Cola de prioridad y suministros que bloquean las operaciones de recuperación.
Dado que es ilimitado, la adición de elementos a veces puede fallar debido al agotamiento de los recursos, lo que resulta en Error de memoria insuficiente . Veamos cómo crear un objeto de cola usando esta clase.
Ejemplo
Java
// 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 pbq> >=>new> PriorityBlockingQueue();> >// 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());> >}> }> |
>
>Producción
10 10 15>
Métodos de interfaz de cola
La interfaz de cola hereda todos los métodos presentes en el interfaz de colecciones mientras implementa los siguientes métodos:
| Método | Descripción |
|---|---|
| agregar(índice int, elemento) | Este método se utiliza para agregar un elemento en un índice particular de la cola. Cuando se pasa un solo parámetro, simplemente agrega el elemento al final de la cola. |
| addAll(índice int, colección colección) | Este método se utiliza para agregar todos los elementos de la colección dada a la cola. Cuando se pasa un solo parámetro, agrega todos los elementos de la colección dada al final de la cola. |
| tamaño() | Este método se utiliza para devolver el tamaño de la cola. |
| claro() | Este método se utiliza para eliminar todos los elementos de la cola. Sin embargo, la referencia de la cola creada todavía se almacena. |
| eliminar() | Este método se utiliza para eliminar el elemento del frente de la cola. |
| eliminar (índice int) | Este método elimina un elemento del índice especificado. Desplaza los elementos posteriores (si los hay) hacia la izquierda y disminuye sus índices en 1. |
| eliminar (elemento) | Este método se utiliza para eliminar y devolver la primera aparición del elemento dado en la cola. |
| obtener (índice int) | Este método devuelve elementos en el índice especificado. |
| conjunto (índice int, elemento) | Este método reemplaza elementos en un índice determinado con el nuevo elemento. Esta función devuelve el elemento que acaba de ser reemplazado por un elemento nuevo. |
| índice de (elemento) | Este método devuelve la primera aparición del elemento dado o -1 si el elemento no está presente en la cola. |
| último índice de (elemento) | Este método devuelve la última aparición del elemento dado o -1 si el elemento no está presente en la cola. |
| es igual (elemento) | Este método se utiliza para comparar la igualdad del elemento dado con los elementos de la cola. |
| código hash() | Este método se utiliza para devolver el valor del código hash de la cola determinada. |
| esta vacio() | Este método se utiliza para comprobar si la cola está vacía o no. Devuelve verdadero si la cola está vacía; en caso contrario, falso. |
| contiene (elemento) | Este método se utiliza para comprobar si la cola contiene el elemento dado o no. Devuelve verdadero si la cola contiene el elemento. |
| contieneTodo(colección colección) | Este método se utiliza para comprobar si la cola contiene toda la colección de elementos. |
| ordenar (comparador comparador) | Este método se utiliza para ordenar los elementos de la cola según el comparador . |
| adición booleana (objeto) | Este método se utiliza para insertar el elemento especificado en una cola y devolver verdadero en caso de éxito. |
| oferta booleana (objeto) | Este método se utiliza para insertar el elemento especificado en la cola. |
| Encuesta de objetos() | Este método se utiliza para recuperar y eliminar el encabezado de la cola, o devuelve nulo si la cola está vacía. |
| Elemento de objeto() | Este método se utiliza para recuperar, pero no eliminar, el encabezado de la cola. |
| Vistazo del objeto() | Este método se utiliza para recuperar, pero no eliminar, el encabezado de esta cola, o devuelve un valor nulo si esta cola está vacía. |
Ventajas de utilizar la interfaz Queue en Java:
Conservación del pedido : La interfaz Queue proporciona una forma de almacenar y recuperar elementos en un orden específico, siguiendo el principio de primero en entrar, primero en salir (FIFO).
Flexibilidad : La interfaz Queue es un subtipo de la interfaz Collection, lo que significa que se puede utilizar con muchas estructuras de datos y algoritmos diferentes, según los requisitos de la aplicación.
Hilo – seguridad : Algunas implementaciones de la interfaz Queue, como la clase java.util.concurrent.ConcurrentLinkedQueue, son seguras para subprocesos, lo que significa que varios subprocesos pueden acceder a ellas simultáneamente sin causar conflictos.
Actuación : La interfaz Queue proporciona implementaciones eficientes para agregar, eliminar e inspeccionar elementos, lo que la convierte en una herramienta útil para administrar colecciones de elementos en aplicaciones críticas para el rendimiento.
Desventajas de utilizar la interfaz Queue en Java:
Funcionalidad limitada: La interfaz Queue está diseñada específicamente para gestionar colecciones de elementos en un orden específico, lo que significa que puede no ser adecuada para estructuras de datos o algoritmos más complejos.
Restricciones de tamaño: Algunas implementaciones de la interfaz Queue, como la clase ArrayDeque, tienen un tamaño fijo, lo que significa que no pueden crecer más allá de una cierta cantidad de elementos.
Uso de memoria: Dependiendo de la implementación, la interfaz Queue puede requerir más memoria que otras estructuras de datos, especialmente si necesita almacenar información adicional sobre el orden de los elementos.
Complejidad : La interfaz Queue puede resultar difícil de usar y comprender para los programadores novatos, especialmente si no están familiarizados con los principios de las estructuras de datos y los algoritmos.