java queue queue methods
În acest tutorial, vom discuta Ce este o coadă în Java, Cum să o utilizați, Exemplu de coadă Java, Metode de coadă Java și Implementarea interfeței cozii:
O coadă este o structură de date liniară sau o colecție în Java care stochează elemente într-o ordine FIFO (First In, First Out).
Colecția de cozi are două capete, adică față și spate. Elementele sunt adăugate în spate și scoase din față.
=> Vizitați aici pentru a vedea seria de antrenament Java pentru toți.
Ce veți învăța:
Ce este o coadă Java?
O structură de date de coadă este reprezentată după cum se arată mai jos:
Așa cum se arată în diagrama de mai sus, o coadă este o structură care are două puncte, adică începutul (fața) și sfârșitul (spatele). Elementele sunt inserate în coada din spate și eliminate din coada din față.
În Java, Coada este o interfață care face parte din pachetul java.util. Interfața cozii extinde interfața Java Collection.
Definiția generală a interfeței cozii este:
public interface Queue extends CollectionDeoarece Coada este o interfață, nu poate fi instanțiată. Avem nevoie de câteva clase concrete pentru a implementa funcționalitatea interfeței Queue. Două clase implementează interfața Queue, adică LinkedList și PriorityQueue.
cea mai bună aplicație de spionaj mobil pentru iPhone
Următoarele sunt câteva dintre caracteristicile majore ale structurii de date Coadă:
- Coada urmează ordinea FIFO (First In, First Out). Aceasta înseamnă că elementul este introdus în coadă la sfârșit și eliminat din coadă la început.
- Interfața de coadă Java oferă toate metodele interfeței de colectare, cum ar fi inserarea, ștergerea etc.
- LinkedList și PriorityQueue sunt clasele care implementează interfața Queue. ArrayBlockingQueue este încă o altă clasă care implementează interfața Queue.
- Cozile care fac parte din pachetul java.util pot fi clasificate ca cozi nelimitate în timp ce cele prezente în pachetul concurent java.util. sunt cozi delimitate.
- Deque este o coadă care acceptă inserarea și ștergerea de la ambele capete.
- Deque este sigur pentru fire.
- BlockingQuesues sunt sigure pentru fire și sunt utilizate pentru a pune în aplicare problemele producător-consumator.
- BlockingQueues nu permit elemente nule. O NullPointerException este aruncată dacă se încearcă orice operație legată de valori nule.
Cum se folosește o coadă în Java?
Pentru a utiliza o coadă în Java, trebuie mai întâi să importăm interfața cozii după cum urmează:
import java.util.queue; Sau
import java.util.*; Odată ce acest lucru este importat, putem crea o coadă așa cum se arată mai jos:
Queue str_queue = new LinkedList (); Deoarece Queue este o interfață, folosim o clasă LinkedList care implementează interfața Queue pentru a crea un obiect de coadă.
În mod similar, putem crea o coadă cu alte clase concrete.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Acum că obiectul coadă este creat, putem inițializa obiectul coadă oferindu-i valorile prin metoda adăugare, așa cum se arată mai jos.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Exemplu de coadă 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); } }Ieșire:
Conținutul cozii: (unul, doi, trei, patru)
Exemplul de mai sus arată declarația și inițializarea unui obiect Queue. Apoi, doar imprimăm conținutul cozii.
Metode de coadă în Java
În această secțiune, vom discuta despre metodele API pentru coadă. Interfața cozii acceptă diverse operații, cum ar fi inserarea, ștergerea, vizionarea etc. Unele operații ridică o excepție, în timp ce unele returnează o anumită valoare atunci când metoda reușește sau eșuează.
Rețineți că nu există modificări specifice colecției Queue în Java 8. Metodele de mai jos sunt disponibile și în versiunile ulterioare ale Java, cum ar fi Java 9 etc.
Tabelul de mai jos rezumă toate aceste metode.
| Metodă | Metoda prototip | Descriere |
|---|---|---|
| mărimea | int size () | Returnează dimensiunea sau numărul de elemente din coadă. |
| adăuga | add boolean (E e) | Adaugă elementul e la coada de la sfârșitul (coada) cozii fără a încălca restricțiile privind capacitatea. Returnează adevărat dacă succesul sau IllegalStateException dacă capacitatea este epuizată. |
| arunca o privire | E peek () | Returnează capul (fața) cozii fără a-l elimina. |
| element | Element E () | Efectuează aceeași operație ca metoda peek (). Aruncă NoSuchElementException când coada este goală. |
| elimina | E elimina () | Îndepărtează capul cozii și îl returnează. Aruncă NoSuchElementException dacă coada este goală. |
| sondaj | Sondaj E () | Îndepărtează capul cozii și îl returnează. Dacă coada este goală, aceasta revine nulă. |
| Oferi | ofertă booleană (E e) | Introduceți noul element e în coadă fără a încălca restricțiile de capacitate. |
Iterarea elementelor cozii
Putem traversa elementele cozii fie folosind bucla forEach, fie folosind un iterator. Programul de mai jos implementează ambele abordări pentru a traversa coada.
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 + ' '); } } }Ieșire:
Elementele cozii prin iterator:
Valoare-0 Valoare-1 Valoare-2 Valoare-3
Elementele cozii folosind bucla for:
Valoare-0 Valoare-1 Valoare-2 Valoare-3
Implementarea cozii Java
Programul de mai jos demonstrează metodele pe care le-am discutat mai sus.
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); } } Ieșire:
Elemente în coadă: (10, 20, 30, 40, 50)
Element eliminat din coadă: 10
Șeful cozii: 20
Sondaj (): returnat Șef de coadă: 20
peek (): Șeful cozii: 30
Coada finală: (30, 40, 50)
Implementarea matricei de coadă Java
Implementarea cozii nu este la fel de simplă ca o implementare a stivei. În primul rând, coada conține două indicatoare, spate și față. De asemenea, se fac operații diferite la două capete diferite.
Pentru a implementa coada utilizând matrici, declarăm mai întâi o matrice care va conține n număr de elemente de coadă.
Apoi definim următoarele operații care trebuie efectuate în această coadă.
# 1) Coada: O operațiune de inserare a unui element în coadă este Enqueue (funcția queueEnqueue în program). Pentru inserarea unui element în partea din spate, trebuie mai întâi să verificăm dacă coada este plină. Dacă este plin, atunci nu putem insera elementul. Dacă este în spate # 2) Stoarceți: Operația de ștergere a unui element din coadă este Dequeue (funcția queueDequeue din program). Mai întâi, verificăm dacă coada este goală. Pentru ca operațiunea de stingere să funcționeze, trebuie să existe cel puțin un element în coadă. # 3) Față: Această metodă returnează partea din față a cozii. # 4) Afișaj: Această metodă parcurge coada și afișează elementele cozii. Următorul program Java demonstrează implementarea Array a cozii. Ieșire: Coada inițială: Deoarece am implementat structura de date a cozii folosind matrici în programul de mai sus, putem implementa și coada utilizând Lista conectată. Vom implementa aceleași metode de coacere, coadă, față și afișare în acest program. Diferența constă în faptul că vom folosi structura de date Linked List în loc de Array. Programul de mai jos demonstrează implementarea Listei corelate a cozii în Java. Ieșire: Elementul 6 a fost adăugat la coadă BlockingQueue este o interfață adăugată în Java 1.5 și face parte din java.util.concurrent pachet. Această interfață introduce blocarea în cazul în care BlockingQueue este complet sau gol. Astfel, atunci când un fir de acces accesează coada și încearcă să introducă (coadă) elemente într-o coadă care este deja plină, este blocat până când un alt fir creează un spațiu în coadă (poate prin operație de coadă sau ștergerea cozii). În mod similar, în cazul stoarcerii, operația este blocată dacă coada este goală până când elementul devine disponibil pentru operația de stingere. Metodele BlockingQueue utilizează o formă de control al concurenței, cum ar fi blocările interne și sunt atomice. BlockingQueue este o coadă simultană care gestionează simultan operațiile de coadă. BlockingQueue este prezentat mai jos: Rețineți că BlockingQueue nu acceptă valori nule. O încercare de a insera o valoare nulă în coadă are ca rezultat NullPointerException. Unele dintre implementările BlockingQueue furnizate în Java sunt LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue și SynchonousQueue. Toate aceste implementări sunt sigure pentru fire. BlockingQuesues sunt de două tipuri: În coada delimitată, capacitatea cozii este transmisă constructorului cozii. Declarația de coadă este după cum urmează: BlockingQueue blockingQueue = nou LinkedBlockingDeque (5); În coada nelimitată, nu setăm în mod explicit capacitatea cozii și poate crește ca dimensiune. Capacitatea este setată la Integer.MAX_VALUE. Declarația cozii nelimitate este după cum urmează: BlockingQueue blockingQueue = new LinkedBlockingDeque (); Interfața BlockingQueue este utilizată în principal pentru tipurile de probleme producător-consumator în care producătorul produce resursele și consumatorul consumă resursele. Q # 1) Ce este o coadă în Java? Răspuns: Coada în Java este o structură de date liniară ordonată care urmează ordinea FIFO (First In, First Out) a elementelor. Aceasta înseamnă că elementul inserat primul în coadă va fi primul element care va fi eliminat. În Java, coada este implementată ca o interfață care moștenește interfața Colecție. Q # 2) Este un Java cu fir de așteptare la coadă? Răspuns: Nu toate cozile sunt thread-safe, dar BlockingQueues în Java sunt thread-safe. Q # 3) Care este mai rapid - Stiva sau Coadă? Răspuns: Stiva este mai rapidă. În stivă, elementele sunt procesate doar dintr-un capăt, prin urmare nu este necesară nicio schimbare. Dar în coadă, elementele trebuie schimbate și ajustate, deoarece există două indicatoare diferite pentru a insera și șterge elemente. Q # 4) Care sunt tipurile cozii? Răspuns: Cozile sunt de următoarele tipuri: Q # 5) De ce se utilizează coada? Răspuns: Structura datelor cozii este utilizată în scopuri de sincronizare. Coada este, de asemenea, utilizată pentru programarea pe disc și CPU. În acest tutorial, am discutat cozile simple împreună cu detaliile lor, cum ar fi declarațiile, implementarea inițializării și metodele. De asemenea, am aflat despre implementarea Array și LinkedList a Queue în Java. În tutorialele noastre viitoare, vom discuta mai multe tipuri de cozi în detaliu. => Verificați TOATE Tutorialele Java aici. 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
Coada este goală
Coadă după operația de așteptare:
10 = 30 = 50 = 70 =
Element frontal al cozii: 10
Coada este plină
10 = 30 = 50 = 70 =
Coada după două operații de coadă: 50 = 70 =
Element frontal al cozii: 50
Implementarea listei legate de coada 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(); } }
Elementul 3 a fost adăugat la coadă
Partea din față a cozii: 6 Partea din spate a cozii: 3
Elementul 12 a fost adăugat la coadă
Elementul 24 a fost adăugat la coadă
Elementul 6 a fost eliminat din coadă
Elementul 3 a fost eliminat din coadă
Elementul 9 a fost adăugat la coadă
Partea din față a cozii: 12 Partea din spate a cozii: 9
BlockingQueue În Java
Tipuri de blocare
Coadă delimitată
Coadă nelimitată
întrebări frecvente
Concluzie
Lectură recomandată