Interfața Queue este prezentă în java.util pachet și extinde Interfață de colecție este folosit pentru a menține elementele pe cale să fie procesate în ordinea FIFO (primul întrat, primul ieşit). Este o listă ordonată de obiecte cu utilizarea sa limitată la inserarea elementelor la sfârșitul listei și ștergerea elementelor de la începutul listei, (adică), urmează FIFO sau principiul First-In-First-Out.
Fiind o interfață coada are nevoie de o clasă concretă pentru declarație, iar cele mai comune clase sunt cele PriorityQueue și LinkedList în Java. Rețineți că niciuna dintre aceste implementări nu este sigură pentru fire. PriorityBlockingQueue este o implementare alternativă dacă este necesară implementarea thread-safe.
Declaraţie: Interfața coadă este declarată ca:
public interface Queue extends Collection>
Crearea obiectelor de coadă: De cand Coadă este o interfață , nu pot fi create obiecte de tip coadă. Avem întotdeauna nevoie de o clasă care extinde această listă pentru a crea un obiect. Și, de asemenea, după introducerea generice în Java 1.5, este posibil să se restricționeze tipul de obiect care poate fi stocat în coadă. Această coadă de tip sigură poate fi definită ca:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
În Java, interfața Queue este un subtip al interfeței Collection și reprezintă o colecție de elemente într-o anumită ordine. Urmează principiul first-in, first-out (FIFO), ceea ce înseamnă că elementele sunt preluate în ordinea în care au fost adăugate la coadă.
Interfața Queue oferă mai multe metode pentru adăugarea, eliminarea și inspectarea elementelor din coadă. Iată câteva dintre cele mai frecvent utilizate metode:
add(element): adaugă un element în spatele cozii. Dacă coada este plină, se aruncă o excepție.
offer(element): adaugă un element în spatele cozii. Dacă coada este plină, se întoarce false.
traversare în ordine
remove(): elimină și returnează elementul din partea din față a cozii. Dacă coada este goală, se aruncă o excepție.
poll(): Îndepărtează și returnează elementul din partea din față a cozii. Dacă coada este goală, returnează null.
element(): returnează elementul din partea din față a cozii fără a-l elimina. Dacă coada este goală, se aruncă o excepție.
peek(): Returnează elementul din partea din față a cozii fără a-l elimina. Dacă coada este goală, returnează null.
Interfața Queue este implementată de mai multe clase în Java, inclusiv LinkedList, ArrayDeque și PriorityQueue. Fiecare dintre aceste clase oferă implementări diferite ale interfeței de coadă, cu caracteristici și caracteristici de performanță diferite.
În general, interfața Queue este un instrument util pentru gestionarea colecțiilor de elemente într-o anumită ordine și este utilizată pe scară largă în multe aplicații și industrii diferite.
Exemplu:
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);> >}> }> |
>
>Ieșire
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Exemplu: Coadă
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);> >}> }> |
>
>Ieșire
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Operații pe interfața de coadă
Să vedem cum să efectuăm câteva operațiuni frecvent utilizate în coadă folosind Clasa Priority Queue .
1. Adăugarea de elemente: Pentru a adăuga un element într-o coadă, putem folosi metoda add(). . Ordinea de inserare nu este reținută în PriorityQueue. Elementele sunt stocate pe baza ordinii de prioritate care este implicit crescătoare.
Exemplu
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);> >}> }> |
>
>Ieșire
[For, Geeks, Geeks]>
2. Îndepărtarea elementelor: Pentru a elimina un element dintr-o coadă, putem folosi metoda remove(). Dacă există mai multe astfel de obiecte, atunci prima apariție a obiectului este eliminată. În afară de asta, metoda poll() este folosită și pentru a elimina capul și a-l returna.
Exemplu
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);> >}> }> |
subșir java
>
>Ieșire
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Repetarea cozii: Există mai multe moduri de a itera prin coadă. Cel mai faimos mod este conversia cozii în matrice și parcurgerea folosind bucla for. Cu toate acestea, coada are, de asemenea, un iterator încorporat care poate fi folosit pentru a itera prin coadă.
Exemplu
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() +>' '>);> >}> >}> }> |
>
>Ieșire
For Geeks Geeks>
Caracteristicile unei cozi: Următoarele sunt caracteristicile cozii:
- Coada este folosită pentru a insera elemente la sfârșitul cozii și elimină de la începutul cozii. Urmează conceptul FIFO.
- Java Queue acceptă toate metodele de interfață de colectare, inclusiv inserarea, ștergerea etc.
- LinkedList , ArrayBlockingQueue și PriorityQueue sunt implementările cel mai frecvent utilizate.
- Dacă se efectuează orice operație nulă pe BlockingQueues, este aruncată NullPointerException.
- Cozile care sunt disponibile în pachetul java.util sunt Cozi nelimitate.
- Cozile care sunt disponibile în pachetul java.util.concurrent sunt Cozile delimitate.
- Toate cozile, cu excepția Deques, acceptă inserarea și eliminarea la coada și, respectiv, la capul cozii. Elementul Deques susține inserarea și îndepărtarea la ambele capete.
Clasele care implementează interfața de coadă:
1. PriorityQueue: Clasa PriorityQueue care este implementată în cadrul de colecție ne oferă o modalitate de a procesa obiectele pe baza priorității. Se știe că o coadă urmează algoritmul First-In-First-Out, dar uneori elementele cozii sunt necesare pentru a fi procesate în funcție de prioritate, atunci când intră în joc PriorityQueue. Să vedem cum să creăm un obiect coadă folosind această clasă.
Exemplu
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());> >}> }> |
>
>Ieșire
10 10 15>
2. Lista legată: LinkedList este o clasă care este implementată în cadrul de colecție care implementează în mod inerent Exemplu
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());> >}> }> |
>
>Ieșire
10 10 20>
3. PriorityBlockingQueue: Trebuie remarcat faptul că ambele implementări, PriorityQueue și LinkedList nu sunt sigure pentru fire. PriorityBlockingQueue este o implementare alternativă dacă este necesară implementarea thread-safe. PriorityBlockingQueue este o coadă de blocare nelimitată care utilizează aceleași reguli de ordonare ca și clasa PriorityQueue și consumabile care blochează operațiunile de recuperare.
Deoarece este nelimitat, adăugarea de elemente poate eșua uneori din cauza epuizării resurselor care rezultă în OutOfMemoryError . Să vedem cum să creăm un obiect coadă folosind această clasă.
Exemplu
Java
govinda
// 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());> >}> }> |
>
>Ieșire
10 10 15>
Metode de interfață coadă
Interfața de coadă moștenește toate metodele prezente în interfața colecțiilor implementând următoarele metode:
| Metodă | Descriere |
|---|---|
| adaugă (index int, element) | Această metodă este folosită pentru a adăuga un element la un anumit index din coadă. Când un singur parametru este trecut, pur și simplu adaugă elementul la sfârșitul cozii. |
| addAll(index int, colecție de colecție) | Această metodă este folosită pentru a adăuga toate elementele din colecția dată la coadă. Când un singur parametru este trecut, acesta adaugă toate elementele colecției date la sfârșitul cozii. |
| mărimea() | Această metodă este folosită pentru a returna dimensiunea cozii. |
| clar() | Această metodă este folosită pentru a elimina toate elementele din coadă. Cu toate acestea, referința cozii create este încă stocată. |
| elimina() | Această metodă este folosită pentru a elimina elementul din partea din față a cozii. |
| elimina (index int) | Această metodă elimină un element din indexul specificat. Mută elementele ulterioare (dacă există) la stânga și le scade indicii cu 1. |
| elimina (element) | Această metodă este folosită pentru a elimina și returna prima apariție a elementului dat din coadă. |
| get(index int) | Această metodă returnează elemente la indexul specificat. |
| set(index int, element) | Această metodă înlocuiește elementele de la un index dat cu noul element. Această funcție returnează elementul care tocmai a fost înlocuit cu un element nou. |
| indexOf(element) | Această metodă returnează prima apariție a elementului dat sau -1 dacă elementul nu este prezent în coadă. |
| lastIndexOf(element) | Această metodă returnează ultima apariție a elementului dat sau -1 dacă elementul nu este prezent în coadă. |
| este egal (element) | Această metodă este folosită pentru a compara egalitatea elementului dat cu elementele cozii. |
| hashCode() | Această metodă este folosită pentru a returna valoarea hashcode a cozii date. |
| este gol() | Această metodă este folosită pentru a verifica dacă coada este goală sau nu. Returnează adevărat dacă coada este goală, altfel fals. |
| conţine(element) | Această metodă este folosită pentru a verifica dacă coada conține elementul dat sau nu. Returnează adevărat dacă coada conține elementul. |
| containsAll(Colecție de colecție) | Această metodă este folosită pentru a verifica dacă coada conține toată colecția de elemente. |
| sortare (comparație de comparație) | Această metodă este folosită pentru a sorta elementele cozii pe baza datei comparator . |
| adăugare booleană (obiect) | Această metodă este folosită pentru a insera elementul specificat într-o coadă și pentru a returna adevărat după succes. |
| oferta booleană (obiect) | Această metodă este folosită pentru a introduce elementul specificat în coadă. |
| Sondaj obiect() | Această metodă este folosită pentru a prelua și elimina capul cozii sau returnează null dacă coada este goală. |
| Element obiect() | Această metodă este folosită pentru a prelua, dar nu pentru a elimina, capul de coadă. |
| Privire obiect() | Această metodă este folosită pentru a extrage, dar nu elimină, capul acestei cozi sau returnează null dacă această coadă este goală. |
Avantajele utilizării interfeței Queue în Java:
Păstrarea comenzii : Interfața Queue oferă o modalitate de a stoca și de a prelua elemente într-o anumită ordine, urmând principiul first-in, first-out (FIFO).
Flexibilitate : Interfața Queue este un subtip al interfeței Collection, ceea ce înseamnă că poate fi utilizată cu multe structuri de date și algoritmi diferiți, în funcție de cerințele aplicației.
Fir – Siguranță : Unele implementări ale interfeței Queue, cum ar fi clasa java.util.concurrent.ConcurrentLinkedQueue, sunt sigure pentru fire, ceea ce înseamnă că pot fi accesate de mai multe fire simultan, fără a provoca conflicte.
Performanţă : Interfața Queue oferă implementări eficiente pentru adăugarea, eliminarea și inspectarea elementelor, ceea ce o face un instrument util pentru gestionarea colecțiilor de elemente în aplicațiile critice pentru performanță.
Dezavantajele utilizării interfeței Queue în Java:
Funcționalitate limitată: Interfața Queue este concepută special pentru gestionarea colecțiilor de elemente într-o anumită ordine, ceea ce înseamnă că poate să nu fie potrivită pentru structuri de date sau algoritmi mai complexe.
Restricții de dimensiune: Unele implementări ale interfeței Queue, cum ar fi clasa ArrayDeque, au o dimensiune fixă, ceea ce înseamnă că nu pot crește dincolo de un anumit număr de elemente.
Folosirea memoriei: În funcție de implementare, interfața Queue poate necesita mai multă memorie decât alte structuri de date, mai ales dacă trebuie să stocheze informații suplimentare despre ordinea elementelor.
Complexitate : Interfața Queue poate fi dificil de utilizat și de înțeles pentru programatorii începători, mai ales dacă nu sunt familiarizați cu principiile structurilor de date și ale algoritmilor.