File d'attente en Java

La structure des données de la file d'attente utilise le principe First In First Out (FIFO). Il permet de conserver les objets à traiter dans l'ordre de leur arrivée ; cela ressemble beaucoup à la file de personnes faisant la queue. Comme Java fournit une large prise en charge de la structure des données sous la forme de l'interface Collection, la file d'attente est une interface disponible dans l'interface Collection. Il étend l'interface Collection. Il est disponible dans le package Java.util et prend en charge toutes les opérations disponibles dans l'interface Collection, ainsi que certaines opérations supplémentaires d'extraction, d'insertion et d'inspection.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

Interface Queue<E>

La file d'attente est une interface, pas une classe, elle ne peut donc pas être instanciée directement. La déclaration montre que la file d'attente accepte les valeurs comme génériques similaires aux collections, et nous pouvons lui transmettre n'importe quel objet. Java a plusieurs implémentations de l'interface Queue, que nous pouvons utiliser lors de l'utilisation des files d'attente. Ce sont LinkedList et PriorityQueue.

Une file d'attente peut être déclarée comme ci-dessous :

Queue< Object > q = new LinkedList<>();

Queue< Object > q = new PriorityQueue<>();

Comment fonctionne la file d'attente en Java ?

• Comme indiqué précédemment, l'interface Queue étend l'interface de collecte ; par conséquent, il prend en charge toutes les méthodes opérationnelles de base disponibles.
• Les implémentations telles que LinkedList et PriorityQueue implémentent les méthodes spécifiques à la file d'attente déclarées dans l'interface Queue.
• La LinkedList contient les éléments comme standard de LinkedList, c'est-à-dire dans l'ordre d'insertion. La PriorityQueue conserve l'ordre naturel des éléments insérés.
• Notez que ces deux implémentations ne sont pas thread-safe, et pour cela, Java fournit une autre implémentation nommée PriorityBlockingQueue, qui est thread-safe.

Types de membres de file d'attente en Java

• Comme la file d'attente est une interface, elle ne contient que des méthodes abstraites et aucune donnée membre.
• La file d'attente fournit uniquement un moyen de définir les opérations implémentées dans les classes enfants.

Fonctions de file d'attente en Java

• Comme la file d'attente prend en charge la structure FIFO, elle permet l'insertion des éléments d'une extrémité et supprime les éléments d'une autre extrémité (avant).
• Ce sont les deux opérations de base prises en charge par une file d'attente.
• Toutes les méthodes disponibles dans une file d'attente peuvent être divisées en deux catégories ; le premier type de méthode lève une exception en cas d'échec de l'opération, par exemple aucun élément trouvé, et dans le deuxième type de méthode, au lieu de l'exception, toute valeur spécifique telle que null ou false est renvoyée en cas d'échec de l'opération .
• Un concept de tête dans une file d'attente représente toujours le premier élément de la file d'attente ; lors du retrait, cet élément de tête sera retiré en premier.

Vous trouverez ci-dessous toutes les méthodes disponibles dans la file d'attente :

	Returns special value	Throws exception
Insert	offer(e)	add(e)
Remove	poll()	remove()
Examine	peek()	element()

  Renvoie une valeur spéciale Lance une exception Insérer offre(e) ajouter(e) Supprimer sondage() supprimer() Examiner peek() élément()

So as explained, two types of methods throw an exception and return a special value. There are three types of operation in this kind of operation: insertion, the second is removal, and the third is retrieval or examination. In the case of the remove operation, an object will be removed from the queue. Still, in the case of examination, the object will be returned without actually removing from the queue.

Examples of Queue in Java

Given below are the different examples of Queue in Java:

Example #1 – Add operation with LinkedList implementation

Code:

import java.util.LinkedList;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
}
}

Output:

Note here that the order of insertion is the same with output from left to write.

Example #2 – Let’s remove the added elements one by one

Code:

import java.util.LinkedList;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
while (!q.isEmpty()) {
System.out.print(q.remove() + " ");
}
System.out.println("");
System.out.println(q);
}
}

Output:

Here, we have used the function isEmpty() to check when the queue becomes empty after removing elements. The removal order is the same as per the insertion. After removing all the elements, we printed the queue and obtained an empty bracket at the end.

Example #3 – Insertion and Removal Operation on PriorityQueue

Code:

import java.util.PriorityQueue;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new PriorityQueue<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
while (!q.isEmpty()) {
System.out.print(q.remove() + " ");
}
System.out.println("");
System.out.println(q);
}
}

Output:

Here, we have used PriorityQueue, which will hold and return the elements depending upon the elements’ natural ordering or upon the comparator, if any passed. Note the insertion order and removal orders are not the same. The removal is based totally on the value of elements.

Example #4 – Examine operation on LinkedList

Code:

import java.util.LinkedList;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
System.out.println( q.peek() );
System.out.println(q);
}
}

Output:

Note here that we have used the peek() function, which will return the head of the queue without actually removing it. We printed the queue after performing the peek operation, and you can observe that the head element, which is 5, remains unchanged in the queue.

Example #5 – Examine operation on PriorityQueue

Code:

import java.util.PriorityQueue;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new PriorityQueue<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
System.out.println( q.peek() );
System.out.println(q);
}
}

Output:

This is similar to the previous example’s LinkedList operation, but note the head element is 1 because it’s a PriorityQueue.

Conclusion

Java utilizes the Queue interface as a means to maintain elements in insertion order. It supports operations like insertion, retrieval, and removal. There are alternative methods available for all the methods. We have seen examples of the most commonly used methods in queue operation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!