Interfața de coadă este o parte din Java.Util pachet și extinde Interfață de colectare . Stochează și procesează datele într -o ordine în care se adaugă elemente în spate și eliminate din față.

Caracteristici cheie

• Comanda FIFO: Elementele sunt procesate în ordinea în care au fost introduse (primul-în primul-ieșire).
• Fără acces aleatoriu: Spre deosebire de elementele de listă nu pot fi accesate direct de Index.
• Mai multe variante: Include implementări PriorityQueue Deque Arraydeque și LinkedList.
• Două seturi de metode: Versiuni de Excepție Aruncă (Adăugați elementul de eliminare) și versiuni sigure (oferirea de sondaj).

Declarația de interfață Java coadă

Interfața de coadă este declarată ca:

Coada de interfață publică extinde colecția

Nu putem instantai o coadă direct, deoarece este o interfață. Aici putem folosi o clasă precum LinkedList sau PriorityQueue care implementează această interfață.

Coadăcoadă = new LinkedList();

comentariu xml

Acum, să parcurgem un exemplu simplu, apoi ne vom scufunda adânc în articol.

Exemplu: coadă de bază folosind LinkedList

import java.util.LinkedList; import java.util.Queue; public class Geeks {    public static void main(String args[])   {  // Create a Queue of Integers using LinkedList  Queue<Integer> q = new LinkedList<>();    System.out.println('Queue elements: ' + q);  } } 

Queue elements: [] 

Fiind o interfață, coada are nevoie de o clasă concretă pentru declarație, iar cele mai frecvente clase sunt Prulityqueue şi LinkedList în Java. Rețineți că niciuna dintre aceste implementări nu este sigură a firului. PriorityBlockingQueue este o implementare alternativă dacă este necesară implementarea sigură a firului.

adder plin adder

Crearea obiectelor de coadă

Coada este o interfață, astfel încât obiectele nu pot fi create de la coada de tip. 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ă restricționarea tipului de obiect care poate fi stocat în coadă. Această coadă de siguranță poate fi definită ca:

// Obj is the type of the object to be stored in Queue Queue<Obj> queue = new PriorityQueue<Obj> (); 

Metode comune

Interfața de coadă oferă mai multe metode pentru adăugarea de eliminare și inspecție a elementelor în coadă. Iată câteva dintre cele mai utilizate metode:

• adaugă (element) : Adaugă un element în spatele cozii. Dacă coada este plină, aruncă o excepție.
• Ofertă (element): Adaugă un element în spatele cozii. Dacă coada este completă, returnează fals.
• elimina() : Elimină și returnează elementul din partea din față a cozii. Dacă coada este goală, aruncă o excepție.
• Sondaj (): Îndepărtează și returnează elementul din partea din față a cozii. Dacă coada este goală, se întoarce nul.
• element(): Returnează elementul din fața cozii fără a -l îndepărta. Dacă coada este goală, aruncă o excepție.
• arunca o privire() : Returnează elementul din partea din față a cozii fără a -l scoate. Dacă coada este goală, se întoarce nul.

Exemplul 1: Acest exemplu demonstrează operațiuni de coadă.

import java.util.LinkedList; import java.util.Queue; public class Geeks {  public static void main(String[] args) {  Queue<String> queue = new LinkedList<>();  // add elements to the queue  queue.add('apple');  queue.add('banana');  queue.add('cherry');  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);  } } 

Queue: [apple banana cherry] Removed element: apple Queue after removal: [banana cherry] Peeked element: banana Queue after peek: [banana cherry date] 

Exemplul 2 :

import java.util.LinkedList; import java.util.Queue; public class Geeks {  public static void main(String[] args){  Queue<Integer> 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);  } } 

Elements of queue: [0 1 2 3 4] Removed element:0 [1 2 3 4] Head of queue:1 Size of queue:4 

Clase care implementează interfața cozii

1.. PriorityQueue

Clasa PriorityQueue ne permite să procesăm elemente bazate pe prioritatea lor în locul ordinii obișnuite FIFO a unei cozi normale. Este util atunci când elementele trebuie gestionate în ordine prioritară. Iată cum putem crea o coadă folosind această clasă.

Exemplu:

imaginea centrală în css

import java.util.*; class Geeks {  public static void main(String args[]){  // Creating empty priority queue  Queue<Integer> pq = new PriorityQueue<Integer>();  // Adding items to the pQueue using add()  pq.add(10);  pq.add(20);  pq.add(15);  // Printing the top element of the PriorityQueue  System.out.println(pq.peek());  // Printing the top element and removing it the PriorityQueue container  System.out.println(pq.poll());  // Printing the top element again  System.out.println(pq.peek());  } } 

10 10 15 

2. LinkedList

LinkedList este o structură liniară de date în care elementele sunt stocate ca obiecte separate fiecare conținând date și o legătură către următorul element. Elementele sunt conectate folosind indicatoarele care nu sunt stocate în memorie continuă. Iată cum putem crea o coadă folosind această clasă.

Exemplu:

import java.util.*; class Geeks {  public static void main(String args[])  {  // Creating empty LinkedList  Queue<Integer> ll = new LinkedList<Integer>();  // 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());  } } 

10 10 20 

3. PriorityBlockingQueue

PriorityBlockingQueue este o coadă de blocare nelimitată sigură de fir care comandă elemente precum PriorityQueue și acceptă blocarea regăsirii. Întrucât elementele adăugate nelimitate pot eșua în cazul în care memoria se termină. Iată cum să creați o coadă folosind această clasă.

Exemplu:

import java.util.concurrent.PriorityBlockingQueue; import java.util.*; class Geeks {  public static void main(String args[])  {  // Creating empty priority blocking queue  Queue<Integer> pbq = new PriorityBlockingQueue<Integer>();  // 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());  } } 

10 10 15 

Diferite operații pe interfața de coadă folosind clasa priorityqueue

1. Adăugarea elementelor

Pentru a adăuga un element într -o coadă, putem folosi Metoda adăugați () . Ordinea de inserare nu este păstrată în PriorityQueue. Elementele sunt stocate pe baza ordinii prioritare care este în mod implicit în mod implicit. 

Exemplu:

lista java este goală

import java.util.*; public class Geeks {  public static void main(String args[])  {  Queue<String> pq = new PriorityQueue<>();  pq.add('Geeks');  pq.add('For');  pq.add('Geeks');  System.out.println(pq);  } } 

[For Geeks Geeks] 

2. Eliminarea elementelor

Pentru a elimina un element dintr -o coadă, putem folosi Metoda eliminați (). Dacă există mai multe obiecte, atunci prima apariție a obiectului este eliminată. Metoda sondajului () este de asemenea folosit pentru a îndepărta capul și a -l returna. 

Exemplu:

import java.util.*; public class Geeks {  public static void main(String args[])  {  Queue<String> 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);  } } 

Initial Queue: [For Geeks Geeks] After Remove: [For Geeks] Poll Method: For Final Queue: [Geeks] 

3. Iterarea cozii

Există mai multe modalități de a itera prin coadă. Cel mai cunoscut mod este transformarea cozii în tablou și traversarea folosind pentru buclă . Coada are, de asemenea, un iterator încorporat care poate fi folosit pentru a itera prin coadă. 

șiruri de caractere java

Exemplu:

import java.util.*; public class Geeks {  public static void main(String args[])  {  Queue<String> pq = new PriorityQueue<>();  pq.add('Geeks');  pq.add('For');  pq.add('Geeks');  Iterator iterator = pq.iterator();  while (iterator.hasNext()) {  System.out.print(iterator.next() + ' ');  }  } } 

For Geeks Geeks 

Metode de interfață de coadă

Iată lista completă a metodelor pentru coadăInterfață în Java împreună cu toate metodele pe care le moștenește din colecțieși iterabil.