Una cola es otro tipo de estructura de datos lineal que se utiliza para almacenar elementos como cualquier otra estructura de datos pero de una manera particular. En palabras simples, podemos decir que la cola es un tipo de estructura de datos en el lenguaje de programación Java que almacena elementos del mismo tipo. Los componentes de una cola se almacenan en un comportamiento FIFO (primero en entrar, primero en salir). Hay dos extremos en la colección de colas, es decir, adelante y atrás. La cola tiene dos extremos: el delantero y el trasero.

La siguiente figura describe perfectamente la propiedad FIFO (primero en entrar, primero en salir) de la cola Java.

Como se explica en la imagen anterior, podemos ver que la cola es una estructura de datos lineal con dos terminales, es decir, inicio (frente) y final (trasero). Los componentes se agregan dentro de la cola desde el extremo posterior de la cola y los componentes se extraen del extremo frontal de la cola.

La cola es una interfaz en el Java que pertenece al paquete Java.util. También amplía la interfaz de Colección.

La representación genérica de la interfaz Java Queue se muestra a continuación:

ordenar una lista de matrices java

 public interface Queue extends Collection 

Como hemos comentado anteriormente, la cola es una interfaz, por lo tanto, también podemos decir que no se puede crear una instancia de la cola porque no se pueden crear instancias de las interfaces. Si un usuario desea implementar la funcionalidad de la interfaz Queue en Java, entonces es obligatorio tener algunas clases sólidas que implementen la interfaz Queue.

En el lenguaje de programación Java, hay dos clases diferentes que se utilizan para implementar la interfaz Queue. Estas clases son:

pruebas de regresión en pruebas de software

• Lista enlazada
• Cola de prioridad

Características de la cola de Java

La cola de Java puede considerarse como una de las estructuras de datos más importantes del mundo de la programación. Java Queue es atractivo por sus propiedades. Las propiedades importantes de la estructura de datos de la cola Java se detallan a continuación:

• Java Queue obedece al método FIFO (primero en entrar, primero en salir). Indica que los elementos se ingresan en la cola al final y se eliminan del frente.
• La interfaz Java Queue proporciona todas las reglas y procesos de la interfaz Collection, como inclusión, eliminación, etc.
• Hay dos clases diferentes que se utilizan para implementar la interfaz Queue. Estas clases son LinkedList y PriorityQueue.
• Aparte de estos dos, existe una clase, Array Blocking Queue, que se utiliza para implementar la interfaz Queue.
• Hay dos tipos de colas: colas ilimitadas y colas delimitadas. Las colas que forman parte del paquete java.util se conocen como colas ilimitadas y las colas limitadas son las colas que están presentes en el paquete java.util.concurrent.
• La Deque o (cola de dos extremos) también es un tipo de cola que lleva la inclusión y eliminación de elementos de ambos extremos.
• El deque también se considera seguro para subprocesos.
• Las colas de bloqueo también son uno de los tipos de colas que también son seguras para subprocesos. Las colas de bloqueo se utilizan para implementar las consultas de productor-consumidor.
• Las colas de bloqueo no admiten elementos nulos. En las colas de bloqueo, si se intenta realizar algún trabajo similar a los valores nulos, también se genera la excepción NullPointerException.

Implementación de cola

Clases utilizadas en la implementación de Queue

Las clases que se utilizan para implementar las funcionalidades de la cola se detallan a continuación:

• ArrayDeque
• Lista enlazada
• Cola de prioridad

Interfaces utilizadas en la implementación de Queue

Las interfaces Java también se utilizan en la implementación de la cola Java. Las interfaces que se utilizan para implementar las funcionalidades de la cola se detallan a continuación:

• Deque
• Cola de bloqueo
• Bloqueo deque

Métodos de clase de cola de Java

En la cola de Java, hay muchos métodos que se utilizan con mucha frecuencia. La interfaz Queue promueve diferentes métodos como insertar, eliminar, mirar, etc. Algunas de las operaciones de la cola Java generan una excepción, mientras que algunas de estas operaciones devuelven un valor particular cuando se completa el programa.

Nota: en Java SE 8, no se realizan cambios en la colección de colas de Java. Estos métodos que se definen a continuación se preparan en las versiones posteriores del lenguaje de programación Java. Por ejemplo, Java SE 9.

A continuación se definen diferentes métodos de la cola Java:

Implementación de matriz de cola de Java

La implementación de la cola no es tan sencilla como la implementación de la pila.

Para implementar la cola usando matrices, primero declaramos una matriz que contiene n elementos.

actor zeenat aman

Luego definimos las siguientes operaciones a realizar en esta cola.

1) Poner en cola: Una operación para insertar un elemento en la cola es Enqueue (función cola Enqueue en el programa). Para insertar un elemento en la parte posterior, primero debemos verificar si la cola está llena. Si está lleno, entonces no podemos insertar el elemento. si trasero

2) Cola: La operación para eliminar un elemento de la cola es Dequeue (función de cola Dequeue en el programa). Primero, verificamos si la cola está vacía. Para que la operación de eliminación de la cola funcione, debe haber al menos un elemento en la cola.

3) Frente: Este método devuelve el principio de la cola.

4) Pantalla: Este método atraviesa la cola y muestra los elementos de la cola.

Programa de cola Java

El siguiente programa Java demuestra la implementación de Queue.

QueueArrayImplementation.java

 class Queue { private static int front, rear, capacity; private static int queue[]; Queue(int size) { front = rear = 0; capacity = size; queue = new int[capacity]; } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue[rear] = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
&apos;); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i <rear 0 4 - 1; i++) { queue[i]="queue[i" + 1]; } set queue[rear] to if (rear < capacity) decrement rear rear--; return; print queue elements static void queuedisplay() int i; (front="=" rear) system.out.printf('queue is empty
'); traverse front and for (i="front;" i rear; system.out.printf(' %d , ', queue[i]); of queuefront() system.out.printf('
front element the queue: %d', queue[front]); public class queuearrayimplementation main(string[] args) create a capacity q="new" queue(4); system.out.println('initial queue:'); q.queuedisplay(); inserting in q.queueenqueue(10); q.queueenqueue(30); q.queueenqueue(50); q.queueenqueue(70); system.out.println('queue after enqueue operation:'); q.queuefront(); insert q.queueenqueue(90); q.queuedequeue(); system.out.printf('
queue two dequeue operations:'); pre> <p> <strong>Output:</strong> </p> <pre> Initial Queue: Queue is Empty Queue after Enqueue Operation: 10 , 30 , 50 , 70 , Front Element of the queue: 10 Queue is full 10 , 30 , 50 , 70 , Queue after two dequeue operations: 50 , 70 , Front Element of the queue: 50 </pre> <h2>Java Queue Linked List Implementation</h2> <p>As we have implemented the Queue data structure using Arrays in the above program, we can also implement the Queue using Linked List.</p> <p>We will implement the same methods enqueue, dequeue, front, and display in this program. The difference is that we will be using the Linked List data structure instead of Array.</p> <p>The below program demonstrates the Linked List implementation of Queue in Java.</p> <p> <strong>QueueLLImplementation.java</strong> </p> <pre> class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front &amp; rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println(&apos;Element &apos; + data+ &apos; removed from the queue&apos;); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println(&apos;Element &apos; + data+ &apos; added to the queue&apos;); } //print front and rear of the queue public void print_frontRear() { System.out.println(&apos;Front of the queue:&apos; + front.data + &apos; Rear of the queue:&apos; + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } </pre> <p> <strong>Output:</strong> </p> <pre> Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9 </pre> <hr></rear>

Implementación de lista enlazada de cola de Java

Como hemos implementado la estructura de datos de la cola usando matrices en el programa anterior, también podemos implementar la cola usando una lista vinculada.

Implementaremos los mismos métodos poner en cola, quitar la cola, frente y mostrar en este programa. La diferencia es que usaremos la estructura de datos de Lista vinculada en lugar de Matriz.

El siguiente programa demuestra la implementación de la lista vinculada de Queue en Java.

QueueLLImplementation.java

cómo ordenar la lista de matrices en java

 class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } 

Producción:

 Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9