La file d’attente Java est une interface disponible dans le package java.util et étend l’interface java.util.Collection. Tout comme la liste Java, la file d’attente Java est une collection d’éléments (ou objets) ordonnée, mais elle effectue des opérations d’insertion et de suppression différemment. Nous pouvons utiliser une file d’attente pour stocker des éléments avant de les traiter. 
File d’attente Java
Dans cette section, nous discuterons de certains points importants sur la file d’attente Java :
- L’interface java.util.Queue est un sous-type de l’interface java.util.Collection.
- Tout comme une file d’attente du monde réel (par exemple, dans une banque ou à un guichet automatique), la file d’attente insère des éléments à la fin de la file et les supprime du début de la file.
- La file d’attente Java représente une liste ordonnée d’éléments.
- La file d’attente Java suit l’ordre FIFO pour insérer et supprimer ses éléments. FIFO signifie « Premier entré, premier sorti ».
- La file d’attente Java prend en charge toutes les méthodes de l’interface Collection.
- Les implémentations de file d’attente les plus fréquemment utilisées sont LinkedList, ArrayBlockingQueue et PriorityQueue.
- Les BlockingQueues n’acceptent pas les éléments nuls. Si nous effectuons une opération liée à null, cela lance une NullPointerException.
- Les BlockingQueues sont utilisées pour implémenter des applications basées sur les producteurs/consommateurs.
- Les BlockingQueues sont thread-safe.
- Toutes les files d’attente disponibles dans le package java.util sont des files d’attente non bornées, et les files d’attente disponibles dans le package java.util.concurrent sont des files d’attente bornées.
- Toutes les files deque ne sont pas thread-safe.
- ConcurrentLinkedQueue est une file d’attente non bornée thread-safe basée sur des nœuds liés.
- Toutes les files d’attente prennent en charge l’insertion à la fin de la file et la suppression au début de la file, sauf les files deque.
- Les files deque sont des files d’attente, mais elles prennent en charge l’insertion et la suppression d’éléments aux deux extrémités.
Diagramme de classe Java Queue
L’interface Java Queue étend l’interface Collection. L’interface Collection étend l’interface Iterable. Certaines des classes d’implémentation de file d’attente fréquemment utilisées sont LinkedList, PriorityQueue, ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, etc. AbstractQueue fournit une implémentation squelettique de l’interface Queue pour réduire les efforts de mise en œuvre de la file d’attente. 
Méthodes de file d’attente Java
Dans cette section, nous discuterons de certaines des méthodes utiles et fréquemment utilisées de la file d’attente Java :
- int size() : pour obtenir le nombre d’éléments dans l’ensemble.
- boolean isEmpty(): pour vérifier si l’ensemble est vide ou non.
- boolean contains(Object o): Renvoie vrai si cet ensemble contient l’élément spécifié.
- Iterator iterator(): Renvoie un itérateur sur les éléments de cet ensemble. Les éléments sont renvoyés dans un ordre quelconque.
- boolean removeAll(Collection c): Supprime de cet ensemble tous ses éléments qui sont contenus dans la collection spécifiée (opération facultative).
- boolean retainAll(Collection c): Conserve uniquement les éléments de cet ensemble qui sont contenus dans la collection spécifiée (opération facultative).
- void clear(): Supprime tous les éléments de l’ensemble.
- E remove(): Retrieves and removes the head of this queue.
- E poll(): Retrieves and removes the head of this queue, or returns null if this queue is empty.
- E peek(): Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
- boolean offer(E e): Insère l’élément spécifié dans cette file d’attente s’il est possible de le faire immédiatement sans violer les restrictions de capacité.
- E element(): Retrieves, but does not remove, the head of this queue.
- boolean add(E e): Insère l’élément spécifié dans cette file d’attente s’il est possible de le faire immédiatement sans violer les restrictions de capacité, renvoyant vrai en cas de succès et lançant une IllegalStateException s’il n’y a actuellement aucun espace disponible.
- Object[] toArray(): Renvoie un tableau contenant tous les éléments de cet ensemble. Si cet ensemble garantit un certain ordre pour le retour de ses éléments par son itérateur, cette méthode doit renvoyer les éléments dans le même ordre.
Principes de base de la file d’attente Java
Comme la file d’attente Java étend la Collection Java, elle prend également en charge toutes les opérations de l’interface Collection. Explorons quelques opérations simples dans l’exemple suivant :
package com.journaldev.queue;
import java.util.*;
public class QueueExample {
public static void main(String[] args) {
Queue queue = new LinkedList<>();
queue.add("one");
queue.add("two");
queue.add("three");
queue.add("four");
System.out.println(queue);
queue.remove("three");
System.out.println(queue);
System.out.println("Queue Size: " + queue.size());
System.out.println("Queue Contains element 'two' or not? : " + queue.contains("two"));
// Pour vider la file d'attente
queue.clear();
}
}
Sortie :-
[one, two, three, four]
[one, two, four]
Queue Size: 3
Queue Contains element 'two' or not? : true
Tableau Java en File d’attente
Ici, nous pouvons explorer comment convertir un tableau Java en file d’attente à l’aide de la méthode « Collections.addAll() » avec un exemple simple.
import java.util.*;
public class ArrayToQueue {
public static void main(String[] args) {
String nums[] = {"one","two","three","four","five"};
Queue<String> queue = new LinkedList<>();
Collections.addAll(queue, nums);
System.out.println(queue);
}
}
Sortie :- Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :
[one, two, three, four, five]
File d’attente Java en tableau
Ici, nous allons explorer comment convertir une file d’attente Java en un tableau Java à l’aide de « toArray() » avec un exemple simple.
import java.util.*;
public class QueueToArray {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("one");
queue.add("two");
queue.add("three");
queue.add("four");
queue.add("five");
String strArray[] = queue.toArray(new String[queue.size()]);
System.out.println(Arrays.toString(strArray));
}
}
Sortie :- Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :
[one, two, three, four, five]
Opérations Courantes de la File d’attente Java
La file d’attente Java prend en charge toutes les opérations prises en charge par l’interface Collection et quelques opérations supplémentaires. Elle prend en charge presque toutes les opérations sous deux formes.
- Un ensemble d’opérations lance une exception si l’opération échoue.
- L’autre ensemble d’opérations retourne une valeur spéciale si l’opération échoue.
Le tableau suivant explique brièvement toutes les opérations courantes de la file d’attente.
| Operation | Throws exception | Special value |
|---|---|---|
| Insert | add(e) | offer(e) |
| Remove | remove() | poll() |
| Examine | element() | peek() |
Nous examinerons chaque opération et les discuterons en détail avec quelques exemples utiles dans les sections suivantes.
Opérations d’insertion de la file d’attente en Java
Dans cette section, nous discuterons en détail de l’opération d’insertion de la file d’attente en Java avec quelques exemples utiles. Si cette opération est réussie, elle renvoie la valeur « true ». Comme nous le savons, la file d’attente prend en charge l’opération d’insertion sous deux formes:
- Queue.add(e): Elle lance une exception si l’opération échoue. Queue.offer(e): Elle renvoie une valeur spéciale si l’opération échoue.
REMARQUE:- Cette valeur spéciale peut être « false » ou « null »
Opération add() de la file d’attente
L’opération add() est utilisée pour insérer un nouvel élément dans la file d’attente. Si elle effectue avec succès l’opération d’insertion, elle renvoie la valeur « true ». Sinon, elle lance java.lang.IllegalStateException. Développons un exemple simple pour illustrer cette fonctionnalité.
import java.util.concurrent.*;
public class QueueAddOperation {
public static void main(String[] args) {
BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);
System.out.println(queue.add("one"));
System.out.println(queue.add("two"));
System.out.println(queue);
System.out.println(queue.add("three"));
System.out.println(queue);
}
}
Sortie:- Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante:
true
true
[one, two]
Exception in thread "main" java.lang.IllegalStateException: Queue full
Comme notre file d’attente est limitée à deux éléments, lorsque nous essayons d’ajouter un troisième élément en utilisant BlockingQueue.add(), une exception est lancée comme indiqué ci-dessus.
Opération d’offre de la file d’attente
L’opération offer() est utilisée pour insérer un nouvel élément dans la file d’attente. Si l’opération d’insertion réussit, elle renvoie la valeur « true ». Sinon, elle renvoie la valeur « false ». Développons un exemple simple pour illustrer cette fonctionnalité.
import java.util.concurrent.*;
public class QueueOfferOperation {
public static void main(String[] args) {
BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);
System.out.println(queue.offer("one"));
System.out.println(queue.offer("two"));
System.out.println(queue);
System.out.println(queue.offer("three"));
System.out.println(queue);
}
}
Sortie:- Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante:
true
true
[one, two]
false
[one, two]
Comme notre file d’attente est limitée à deux éléments, lorsque nous essayons d’ajouter un troisième élément en utilisant l’opération BlockingQueue.offer(), elle renvoie la valeur « false » comme indiqué ci-dessus.
Opérations de suppression de file d’attente Java
Dans cette section, nous discuterons en détail de l’opération de suppression de file d’attente Java avec quelques exemples utiles. Les opérations de suppression renvoient l’élément de tête de la file d’attente si elles réussissent. Comme nous le savons, la file d’attente prend en charge l’opération de suppression sous deux formes:
- Queue.remove():
Il lance une exception si l’opération échoue.- Queue.poll():
Il renvoie une valeur spéciale si l’opération échoue.
REMARQUE:- Ici, la valeur spéciale peut être soit « false » soit « null »
Opération de suppression de la file d’attente
L’opération remove() est utilisée pour supprimer un élément de la tête de la file d’attente. Si elle effectue avec succès l’opération de suppression, elle renvoie l’élément de tête de la file d’attente. Sinon, elle lance java.util.NoSuchElementException. Développons un exemple simple pour démontrer cette fonctionnalité.
import java.util.*;
public class QueueRemoveOperation
{
public static void main(String[] args)
{
Queue<String> queue = new LinkedList<>();
queue.offer("one");
queue.offer("two");
System.out.println(queue);
System.out.println(queue.remove());
System.out.println(queue.remove());
System.out.println(queue.remove());
}
}
Sortie:- Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :
[one, two]
one
two
Exception in thread "main" java.util.NoSuchElementException
Comme notre file d’attente n’a que deux éléments, lorsque nous essayons d’appeler la méthode remove() pour la troisième fois, elle lance une exception comme indiqué ci-dessus. REMARQUE:- Queue.remove(element) est utilisée pour supprimer un élément spécifié de la file d’attente. Si elle effectue avec succès l’opération de suppression, elle renvoie la valeur « true ». Sinon, elle renvoie la valeur « false ».
Opération de sondage de la file d’attente
L’opération poll() est utilisée pour supprimer un élément de la tête de la file d’attente. Si elle effectue avec succès l’opération de suppression, elle renvoie l’élément de tête de la file d’attente. Sinon, elle renvoie la valeur « null ». Développons un exemple simple pour démontrer cette fonctionnalité.
import java.util.*;
public class QueuePollOperation
{
public static void main(String[] args)
{
Queue<String> queue = new LinkedList<>();
queue.offer("one");
queue.offer("two");
System.out.println(queue);
System.out.println(queue.poll());
System.out.println(queue.poll());
System.out.println(queue.poll());
}
}
Sortie:- Lorsque nous exécutons le programme ci-dessus, nous obtiendrons la sortie suivante:
[one, two]
one
two
null
Comme notre file n’a que deux éléments, lorsque nous essayons d’appeler la méthode poll() pour la troisième fois, elle renvoie une valeur nulle comme indiqué ci-dessus.
Opérations d’examen de la file d’attente Java
Dans cette section, nous discuterons en détail des opérations d’examen de la file d’attente Java avec quelques exemples utiles. Si cette opération réussit, elle renvoie l’élément en tête de la file d’attente sans le supprimer. Comme nous le savons, la file d’attente prend en charge l’opération d’examen sous deux formes:
- Queue.element():
Il lance une exception si l’opération échoue.- Queue.peek():
Il renvoie une valeur spéciale si l’opération échoue.
REMARQUE:- Ici, la valeur spéciale peut être soit « faux » soit « nulle »
Opération d’élément de la file d’attente
L’opération element() est utilisée pour récupérer un élément en tête de la file d’attente, sans le supprimer. Si l’opération d’examen réussit, elle renvoie l’élément en tête de la file d’attente. Sinon, elle lance java.util.NoSuchElementException. Développons un exemple simple pour illustrer cette fonctionnalité.
import java.util.*;
public class QueueElementOperation {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("one");
System.out.println(queue.element());
System.out.println(queue);
queue.clear();
System.out.println(queue.element());
}
}
Sortie:- Lorsque nous exécutons le programme ci-dessus, nous obtiendrons la sortie suivante:
one
[one]
Exception in thread "main" java.util.NoSuchElementException
Si nous essayons d’appeler la méthode element() sur une file vide, elle génère une exception comme indiqué ci-dessus.
Opération peek() de la file
L’opération peek() est utilisée pour récupérer un élément de la tête de la file, sans le supprimer. Si elle réussit l’opération d’examen, elle renvoie l’élément de tête de la file. Sinon, elle renvoie la valeur null. Développons un exemple simple pour illustrer cette fonctionnalité.
import java.util.*;
public class QueuePeekOperation {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("one");
System.out.println(queue.peek());
System.out.println(queue);
queue.clear();
System.out.println(queue.peek());
}
}
Sortie : Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :
one
[one]
null
Si nous essayons d’appeler la méthode peek() sur une file vide, elle renvoie la valeur null, mais ne génère PAS d’exception comme indiqué ci-dessus.
Catégories de files Java
En Java, nous pouvons trouver de nombreuses implémentations de files. Nous pouvons les classer largement en deux types suivants
- Files bornées
- Files non bornées
Les files d’attente bornées sont des files d’attente qui sont limitées par une capacité, ce qui signifie que nous devons fournir la taille maximale de la file d’attente au moment de sa création. Par exemple, ArrayBlockingQueue (voir exemple précédent). Les files d’attente non bornées sont des files d’attente qui ne sont PAS limitées par une capacité, ce qui signifie que nous ne devrions pas fournir la taille de la file d’attente. Par exemple, LinkedList (voir exemple précédent). Toutes les files d’attente disponibles dans le package java.util sont des files d’attente non bornées et les files d’attente disponibles dans le package java.util.concurrent sont des files d’attente bornées. Autrement dit, nous pouvons les classer largement en deux types suivants:
- Files d’attente bloquantes
- Files d’attente non bloquantes
Toutes les files d’attente qui implémentent l’interface BlockingQueue sont des files d’attente bloquantes et les autres sont des files d’attente non bloquantes. Les files d’attente bloquantes bloquent jusqu’à ce qu’elles aient terminé leur tâche ou qu’un délai soit dépassé, mais les files d’attente non bloquantes ne le font pas. Certaines files d’attente sont des Deques et certaines sont des PriorityQueues.
Opérations de la file d’attente bloquante
En plus des deux formes d’opérations de la file d’attente, les files d’attente bloquantes prennent en charge deux autres formes, comme indiqué ci-dessous.
| Operation | Throws exception | Special value | Blocks | Times out |
|---|---|---|---|---|
| Insert | add(e) | offer(e) | put(e) | offer(e, time, unit) |
| Remove | remove() | poll() | take() | poll(time, unit) |
| Examine | element() | peek() | N/A | N/A |
Certaines opérations sont bloquées jusqu’à ce qu’elles aient terminé leur tâche et d’autres sont bloquées jusqu’à expiration du délai. Voilà un bref aperçu des files d’attente en Java. J’espère que ces exemples de files d’attente en Java vous aideront à démarrer la programmation de collections de files d’attente. N’hésitez pas à me laisser un commentaire si vous aimez mes tutoriels ou si vous avez des suggestions, des problèmes ou des erreurs de frappe. Merci.
Source:
https://www.digitalocean.com/community/tutorials/java-queue