java queue queue methods
En aquest tutorial, discutirem què és una cua a Java, com s'utilitza, exemple de cua de Java, mètodes de cua de Java i implementació de la interfície de cua:
Una cua és una estructura de dades lineal o una col·lecció a Java que emmagatzema elements en un ordre FIFO (First In, First Out).
La col·lecció de cues té dos extrems, és a dir, frontal i posterior. Els elements s’afegeixen a la part posterior i s’eliminen de la part davantera.
=> Visiteu aquí per veure la sèrie de formació de Java per a tothom
millor programa per desfer-se del programari maliciós
Què aprendreu:
Què és una cua de Java?
Es representa una estructura de dades de cua com es mostra a continuació:
Com es mostra al diagrama anterior, una cua és una estructura que té dos punts, és a dir, inicial (frontal) i final (posterior). Els elements s’insereixen a la cua de la part posterior i s’eliminen de la cua de la part frontal.
A Java, la cua és una interfície que forma part del paquet java.util. La interfície de cua amplia la interfície Java Collection.
La definició general de la interfície de la cua és:
public interface Queue extends CollectionCom que la cua és una interfície, no es pot crear una instància. Necessitem algunes classes concretes per implementar la funcionalitat de la interfície de la cua. Dues classes implementen la interfície de la cua, és a dir, LinkedList i PriorityQueue.
A continuació es detallen algunes de les principals característiques de l'estructura de dades de la cua:
- La cua segueix l’ordre FIFO (First In, First Out). Això significa que l’element s’insereix a la cua al final i s’elimina de la cua al principi.
- La interfície de cua de Java proporciona tots els mètodes de la interfície de col·lecció, com ara inserció, supressió, etc.
- LinkedList i PriorityQueue són les classes que implementen la interfície de la cua. ArrayBlockingQueue és una altra classe que implementa la interfície de la cua.
- Les cues que formen part del paquet java.util es poden classificar com a cues il·limitades mentre que les presents a java.util.the paquet simultani són cues delimitades.
- El Deque és una cua que admet la inserció i la supressió dels dos extrems.
- La deque és segura per a fils.
- Les cues de bloqueig són segures per a fils i s’utilitzen per implementar problemes entre productors i consumidors.
- BlockingQueues no permet elements nuls. Es genera una excepció NullPointerException si s’intenta fer alguna operació relacionada amb valors nuls.
Com s'utilitza una cua a Java?
Per utilitzar una cua a Java, primer hem d'importar la interfície de la cua de la següent manera:
import java.util.queue; O bé
import java.util.*; Un cop importat, podem crear una cua com es mostra a continuació:
Queue str_queue = new LinkedList (); Com que la cua és una interfície, fem servir una classe LinkedList que implementa la interfície de la cua per crear un objecte de cua.
De la mateixa manera, podem crear una cua amb altres classes concretes.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Ara que es crea l'objecte de cua, podem inicialitzar l'objecte de cua proporcionant-li els valors mitjançant el mètode add, tal com es mostra a continuació.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Exemple de cua de Java
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue str_queue = new LinkedList(); //initialize the queue with values str_queue.add('one'); str_queue.add('two'); str_queue.add('three'); str_queue.add('four'); //print the Queue System.out.println('The Queue contents:' + str_queue); } }Sortida:
El contingut de la cua: (un, dos, tres, quatre)
L'exemple anterior mostra la declaració i la inicialització d'un objecte de cua. A continuació, només imprimim el contingut de la cua.
Mètodes de cua a Java
En aquesta secció, parlarem dels mètodes de l'API per a la cua. La interfície de cua admet diverses operacions, com ara inserir, suprimir, mirar, etc. Algunes operacions generen una excepció, mentre que algunes retornen un valor específic quan el mètode té èxit o falla.
Tingueu en compte que no hi ha canvis específics a la col·lecció de cues a Java 8. Els mètodes següents també estan disponibles en versions posteriors de Java, com ara Java 9, etc.
La taula següent resumeix tots aquests mètodes.
| Mètode | Mètode prototip | Descripció |
|---|---|---|
| mida | int size () | Retorna la mida o el nombre d'elements a la cua. |
| afegir | addició booleana (E e) | Afegeix l'element e a la cua al final (cua) de la cua sense violar les restriccions de capacitat. Retorna cert si té èxit o excepció IllegalStateException si s’esgota la capacitat. |
| ullada | E peek () | Retorna el cap (frontal) de la cua sense treure-la. |
| element | Element E () | Realitza la mateixa operació que el mètode peek (). Llença NoSuchElementException quan la cua està buida. |
| eliminar | Eliminar () | Elimina el cap de la cua i el retorna. Llença NoSuchElementException si la cua està buida. |
| enquesta | Enquesta E () | Elimina el cap de la cua i el retorna. Si la cua està buida, torna nul·la. |
| Oferta | oferta booleana (E e) | Inseriu el nou element e a la cua sense infringir les restriccions de capacitat. |
Iteració dels elements de la cua
Podem recórrer els elements de la cua mitjançant el bucle forEach o mitjançant un iterador. El programa que es mostra a continuació implementa els dos enfocaments per recórrer la cua.
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue LL_queue = new LinkedList(); //initialize the Queue LL_queue.add('Value-0'); LL_queue.add('Value-1'); LL_queue.add('Value-2'); LL_queue.add('Value-3'); //traverse the Queue using Iterator System.out.println('The Queue elements through iterator:'); Iterator iterator = LL_queue.iterator(); while(iterator.hasNext()){ String element = (String) iterator.next(); System.out.print(element + ' '); } System.out.println('
The Queue elements using for loop:'); //use new for loop to traverse the Queue for(Object object : LL_queue) { String element = (String) object; System.out.print(element + ' '); } } }Sortida:
Els elements de la cua mitjançant l'iterador:
Valor-0 Valor-1 Valor-2 Valor-3
Els elements de la cua que utilitzen el bucle for:
Valor-0 Valor-1 Valor-2 Valor-3
Implementació de la cua de Java
El programa següent mostra els mètodes que hem comentat anteriorment.
import java.util.*; public class Main { public static void main(String() args) { Queue q1 = new LinkedList(); //Add elements to the Queue q1.add(10); q1.add(20); q1.add(30); q1.add(40); q1.add(50); System.out.println('Elements in Queue:'+q1); //remove () method =>removes first element from the queue System.out.println('Element removed from the queue: '+q1.remove()); //element() => returns head of the queue System.out.println('Head of the queue: '+q1.element()); //poll () => removes and returns the head System.out.println('Poll():Returned Head of the queue: '+q1.poll()); //returns head of the queue System.out.println('peek():Head of the queue: '+q1.peek()); //print the contents of the Queue System.out.println('Final Queue:'+q1); } } Sortida:
Elements a la cua: (10, 20, 30, 40, 50)
Element eliminat de la cua: 10
Cap de cua: 20
Enquesta (): cap de cua retornat: 20
peek (): Cap de cua: 30
Final Queue: (30, 40, 50)
Implementació de matriu de cues de Java
La implementació de la cua no és tan senzilla com una implementació de pila. Primer de tot, la cua conté dos indicadors, posterior i frontal. A més, es fan diferents operacions en dos extrems diferents.
Per implementar la cua mitjançant matrius, primer declarem una matriu que contindrà n nombre d'elements de cua.
A continuació, definim les següents operacions a realitzar en aquesta cua.
# 1) Cola: Una operació per inserir un element a la cua és Enqueue (funció queueEnqueue al programa). Per inserir un element a la part posterior, primer hem de comprovar si la cua està plena. Si està ple, no podem inserir l'element. Si és posterior # 2) Retardar: L'operació per suprimir un element de la cua és Dequeue (funció queueDequeue al programa). En primer lloc, comprovem si la cua està buida. Perquè l’operació de cola funcioni, ha d’haver com a mínim un element a la cua. # 3) Davant: Aquest mètode retorna la part frontal de la cua. # 4) Pantalla: Aquest mètode recorre la cua i mostra els elements de la cua. El següent programa Java mostra la implementació de matriu de la cua. Sortida: Cua inicial: Com que hem implementat l'estructura de dades de la cua amb matrius al programa anterior, també podem implementar la cua mitjançant la llista enllaçada. Implementarem els mateixos mètodes de cola, cola, frontal i visualització en aquest programa. La diferència és que utilitzarem l’estructura de dades de la Llista enllaçada en lloc de la matriu. El programa següent mostra la implementació de la Llista enllaçada de la cua a Java. Sortida: S'ha afegit l'element 6 a la cua BlockingQueue és una interfície afegida a Java 1.5 i que forma part del fitxer java.util.concurrent paquet. Aquesta interfície introdueix el bloqueig en cas que la BlockingQueue estigui plena o buida. Així, quan un fil accedeix a la cua i intenta inserir (posar en cua) elements en una cua que ja està plena, es bloqueja fins que un altre fil crea un espai a la cua (potser per operació de cola o per netejar la cua). De la mateixa manera, en el cas de deixar de colar, l'operació es bloqueja si la cua està buida fins que l'element estigui disponible per a l'operació de cola. Els mètodes BlockingQueue utilitzen alguna forma de control de simultaneïtat, com ara panys interns, i són atòmics. La BlockingQueue és una cua simultània que gestiona les operacions de la cua simultàniament. A continuació es mostra la BlockingQueue: Tingueu en compte que BlockingQueue no accepta valors nuls. Un intent d’inserir un valor nul a la cua dóna lloc a NullPointerException. Algunes de les implementacions BlockingQueue proporcionades a Java són LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue i SynchonousQueue. Totes aquestes implementacions són segures per a fils. Les cues de bloqueig són de dos tipus: A la cua delimitada, la capacitat de la cua es passa al constructor de la cua. La declaració de cua és la següent: BlockingQueue blockingQueue = nou LinkedBlockingDeque (5); A la cua il·limitada, no establim la capacitat de la cua explícitament i pot créixer. La capacitat s'estableix en Integer.MAX_VALUE. La declaració de la cua il·limitada és la següent: BlockingQueue blockingQueue = nou LinkedBlockingDeque (); La interfície BlockingQueue s'utilitza principalment per a problemes de tipus productor-consumidor en què el productor produeix els recursos i el consumidor els consumeix. P # 1) Què és una cua a Java? Resposta: La cua a Java és una estructura de dades ordenada lineal que segueix l’ordenació d’elements FIFO (First In, First Out). Això vol dir que l'element inserit primer a la cua serà el primer element que es traurà. A Java, la cua s’implementa com una interfície que hereta la interfície de col·lecció. Q # 2) És un Java amb fil per a la cua? Resposta: No totes les cues són segures per a fils, però BlockingQueues a Java són per a fils. Q # 3) Què és més ràpid: pila o cua? Resposta: La pila és més ràpida. A la pila, els elements només es processen des d’un extrem, per tant no es requereix cap canvi. Però a la cua, cal canviar i ajustar els elements, ja que hi ha dos indicadors diferents per inserir i eliminar elements. Q # 4) Quins són els tipus de cua? Resposta: les cues són dels tipus següents: Q # 5) Per què s’utilitza la cua? Resposta: L’estructura de dades de la cua s’utilitza amb finalitats de sincronització. La cua també s'utilitza per a la programació de discs i CPU. En aquest tutorial, hem debatut sobre les cues simples juntament amb els seus detalls com declaracions, implementació d'inicialització i mètodes. També vam aprendre sobre la implementació Array i LinkedList de Queue a Java. En els nostres propers tutorials, analitzarem detalladament més tipus de cues. => Consulteu TOTS els tutorials de Java aquí. 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
'); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i
La cua és buida
Cua després de l'operació de cola:
10 = 30 = 50 = 70 =
Element frontal de la cua: 10
La cua està plena
10 = 30 = 50 = 70 =
Cua després de dues operacions de cola: 50 = 70 =
Element frontal de la cua: 50
Implementació de la llista enllaçada de cua de 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 Main{ 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(); } }
S'ha afegit l'element 3 a la cua
Part davantera de la cua: 6 Part posterior de la cua: 3
S'ha afegit l'element 12 a la cua
S'ha afegit l'element 24 a la cua
L'element 6 s'ha eliminat de la cua
L'element 3 s'ha eliminat de la cua
S'ha afegit l'element 9 a la cua
Part davantera de la cua: 12 Part posterior de la cua: 9
BlockingQueue A Java
Tipus de blocs de cua
Cua delimitada
Cua sense límits
Linux funcionarà més ràpid que Windows
Preguntes freqüents
Conclusió
Lectura recomanada