L'interface Queue est présente dans java.util paquet et étend le Interface de collecte est utilisé pour contenir les éléments sur le point d'être traités dans l'ordre FIFO (First In First Out). Il s'agit d'une liste ordonnée d'objets dont l'utilisation est limitée à l'insertion d'éléments à la fin de la liste et à la suppression d'éléments depuis le début de la liste (c'est-à-dire qu'elle suit le FIFO ou le principe du premier entré, premier sorti.
Étant une interface, la file d'attente a besoin d'une classe concrète pour la déclaration et les classes les plus courantes sont les File d'attente de priorité et Liste liée en Java. Notez qu’aucune de ces implémentations n’est thread-safe. File d'attente de blocage prioritaire est une implémentation alternative si l’implémentation thread-safe est nécessaire.
Déclaration: L'interface Queue est déclarée comme :
public interface Queue extends Collection>
Création d'objets de file d'attente : Depuis File d'attente est un interface , les objets de type file d'attente ne peuvent pas être créés. Nous avons toujours besoin d'une classe qui étend cette liste afin de créer un objet. Et aussi, après l'introduction de Génériques dans Java 1.5, il est possible de restreindre le type d'objet pouvant être stocké dans la file d'attente. Cette file d'attente de type sécurisé peut être définie comme :
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
En Java, l'interface Queue est un sous-type de l'interface Collection et représente une collection d'éléments dans un ordre spécifique. Il suit le principe du premier entré, premier sorti (FIFO), ce qui signifie que les éléments sont récupérés dans l'ordre dans lequel ils ont été ajoutés à la file d'attente.
L'interface Queue propose plusieurs méthodes pour ajouter, supprimer et inspecter des éléments dans la file d'attente. Voici quelques-unes des méthodes les plus couramment utilisées :
add(element) : ajoute un élément à l’arrière de la file d’attente. Si la file d'attente est pleine, une exception est levée.
offer(element) : ajoute un élément à l’arrière de la file d’attente. Si la file d'attente est pleine, elle renvoie false.
Remove() : supprime et renvoie l'élément en début de file d'attente. Si la file d'attente est vide, une exception est levée.
poll() : supprime et renvoie l'élément en début de file d'attente. Si la file d'attente est vide, elle renvoie null.
element() : renvoie l'élément en début de file d'attente sans le supprimer. Si la file d'attente est vide, une exception est levée.
peek() : renvoie l'élément en début de file d'attente sans le supprimer. Si la file d'attente est vide, elle renvoie null.
L'interface Queue est implémentée par plusieurs classes en Java, notamment LinkedList, ArrayDeque et PriorityQueue. Chacune de ces classes fournit différentes implémentations de l'interface de file d'attente, avec des caractéristiques et des fonctionnalités de performances différentes.
Dans l'ensemble, l'interface Queue est un outil utile pour gérer des collections d'éléments dans un ordre spécifique et est largement utilisée dans de nombreuses applications et secteurs différents.
Exemple:
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);> > }> }> |
>
>Sortir
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Exemple: File d'attente
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);> > }> }> |
>
chaîne en entier en java
>Sortir
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Opérations sur l'interface de file d'attente
Voyons comment effectuer quelques opérations fréquemment utilisées sur la file d'attente à l'aide du Classe de file d'attente prioritaire .
1. Ajout d'éléments : Afin d'ajouter un élément dans une file d'attente, nous pouvons utiliser le méthode ajouter() . L'ordre d'insertion n'est pas conservé dans PriorityQueue. Les éléments sont stockés selon l'ordre de priorité qui est croissant par défaut.
Exemple
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);> > }> }> |
>
>Sortir
[For, Geeks, Geeks]>
2. Suppression d'éléments : Afin de supprimer un élément d'une file d'attente, nous pouvons utiliser le méthode Remove(). S'il existe plusieurs objets de ce type, la première occurrence de l'objet est supprimée. En dehors de cela, la méthode poll() est également utilisée pour supprimer la tête et la renvoyer.
Exemple
Java
java sinon si
// 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);> > }> }> |
>
>Sortir
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Itération de la file d'attente : Il existe plusieurs façons de parcourir la file d’attente. La méthode la plus connue consiste à convertir la file d'attente en tableau et à la parcourir à l'aide de la boucle for. Cependant, la file d'attente dispose également d'un itérateur intégré qui peut être utilisé pour parcourir la file d'attente.
Exemple
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() +> ' '> );> > }> > }> }> |
>
>Sortir
For Geeks Geeks>
Caractéristiques d'une file d'attente : Voici les caractéristiques de la file d'attente :
- La file d'attente est utilisée pour insérer des éléments à la fin de la file d'attente et les supprimer depuis le début de la file d'attente. Il suit le concept FIFO.
- La file d'attente Java prend en charge toutes les méthodes de l'interface Collection, y compris l'insertion, la suppression, etc.
- Liste liée , ArrayBlockingQueue et File d'attente de priorité sont les implémentations les plus fréquemment utilisées.
- Si une opération nulle est effectuée sur BlockingQueues, NullPointerException est levée.
- Les files d'attente disponibles dans le package java.util sont des files d'attente illimitées.
- Les files d'attente disponibles dans le package java.util.concurrent sont les files d'attente délimitées.
- Toutes les files d'attente, à l'exception des Deques, prennent en charge l'insertion et la suppression respectivement en queue et en tête de la file d'attente. Les Deques prennent en charge l'insertion et le retrait d'éléments aux deux extrémités.
Classes qui implémentent l'interface de file d'attente :
1. File d'attente prioritaire : La classe PriorityQueue qui est implémentée dans le framework de collection nous fournit un moyen de traiter les objets en fonction de la priorité. On sait qu’une file d’attente suit l’algorithme First-In-First-Out, mais parfois les éléments de la file d’attente doivent être traités en fonction de la priorité, c’est alors que la PriorityQueue entre en jeu. Voyons comment créer un objet file d'attente à l'aide de cette classe.
Exemple
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());> > }> }> |
>
>Sortir
10 10 15>
2. Liste liée : LinkedList est une classe implémentée dans le cadre de collection qui implémente intrinsèquement le Exemple
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());> > }> }> |
>
>Sortir
10 10 20>
3. File d'attente de blocage prioritaire : Il convient de noter que les deux implémentations, PriorityQueue et LinkedList, ne sont pas thread-safe. PriorityBlockingQueue est une implémentation alternative si une implémentation thread-safe est nécessaire. PriorityBlockingQueue est une file d'attente de blocage illimitée qui utilise les mêmes règles de classement que la classe File d'attente de priorité et des fournitures bloquant les opérations de récupération.
Puisqu'il est illimité, l'ajout d'éléments peut parfois échouer en raison de l'épuisement des ressources, ce qui entraîne Erreur de mémoire insuffisante . Voyons comment créer un objet file d'attente à l'aide de cette classe.
Exemple
Java
// 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());> > }> }> |
>
>Sortir
10 10 15>
Méthodes d'interface de file d'attente
L'interface de file d'attente hérite de toutes les méthodes présentes dans le interface de collecte tout en mettant en œuvre les méthodes suivantes :
Méthode | Description dépôt maven |
---|---|
ajouter (int index, élément) | Cette méthode est utilisée pour ajouter un élément à un index particulier dans la file d'attente. Lorsqu'un seul paramètre est passé, il ajoute simplement l'élément à la fin de la file d'attente. |
addAll (index int, collection collection) | Cette méthode est utilisée pour ajouter tous les éléments de la collection donnée à la file d'attente. Lorsqu'un seul paramètre est passé, il ajoute tous les éléments de la collection donnée à la fin de la file d'attente. |
taille() | Cette méthode est utilisée pour renvoyer la taille de la file d'attente. |
clair() | Cette méthode est utilisée pour supprimer tous les éléments de la file d'attente. Cependant, la référence de la file d'attente créée est toujours stockée. |
retirer() | Cette méthode est utilisée pour supprimer l’élément du début de la file d’attente. |
supprimer (index int) | Cette méthode supprime un élément de l'index spécifié. Il décale les éléments suivants (le cas échéant) vers la gauche et diminue leurs index de 1. |
supprimer (élément) | Cette méthode est utilisée pour supprimer et renvoyer la première occurrence de l'élément donné dans la file d'attente. |
obtenir (index int) | Cette méthode renvoie les éléments à l'index spécifié. |
set (int index, élément) | Cette méthode remplace les éléments d'un index donné par le nouvel élément. Cette fonction renvoie l'élément qui vient d'être remplacé par un nouvel élément. |
indexDe(élément) | Cette méthode renvoie la première occurrence de l'élément donné ou -1 si l'élément n'est pas présent dans la file d'attente. |
dernierIndexDe(élément) | Cette méthode renvoie la dernière occurrence de l'élément donné ou -1 si l'élément n'est pas présent dans la file d'attente. |
est égal à (élément) | Cette méthode est utilisée pour comparer l'égalité de l'élément donné avec les éléments de la file d'attente. |
code de hachage() | Cette méthode est utilisée pour renvoyer la valeur du hashcode de la file d'attente donnée. |
est vide() | Cette méthode est utilisée pour vérifier si la file d'attente est vide ou non. Il renvoie vrai si la file d'attente est vide, sinon faux. |
contient (élément) | Cette méthode est utilisée pour vérifier si la file d'attente contient l'élément donné ou non. Il renvoie vrai si la file d'attente contient l'élément. |
contientTout (Collection collection) | Cette méthode est utilisée pour vérifier si la file d'attente contient toute la collection d'éléments. |
trier (composition de comparaison) | Cette méthode est utilisée pour trier les éléments de la file d'attente en fonction des valeurs données. comparateur . |
booléen ajouter (objet) | Cette méthode est utilisée pour insérer l'élément spécifié dans une file d'attente et renvoyer true en cas de succès. |
offre booléenne (objet) | Cette méthode est utilisée pour insérer l'élément spécifié dans la file d'attente. |
Sondage d'objet() | Cette méthode est utilisée pour récupérer et supprimer la tête de la file d'attente, ou renvoie null si la file d'attente est vide. |
Élément d'objet() | Cette méthode est utilisée pour récupérer, mais ne supprime pas, la tête de file d'attente. |
Aperçu de l'objet() | Cette méthode est utilisée pour récupérer, mais ne supprime pas, la tête de cette file d'attente, ou renvoie null si cette file d'attente est vide. |
Avantages de l'utilisation de l'interface Queue en Java :
Conservation des commandes : L'interface Queue permet de stocker et de récupérer des éléments dans un ordre spécifique, selon le principe du premier entré, premier sorti (FIFO).
La flexibilité : L'interface Queue est un sous-type de l'interface Collection, ce qui signifie qu'elle peut être utilisée avec de nombreuses structures de données et algorithmes différents, en fonction des exigences de l'application.
Fil – sécurité : Certaines implémentations de l'interface Queue, telles que la classe java.util.concurrent.ConcurrentLinkedQueue, sont thread-safe, ce qui signifie qu'elles sont accessibles par plusieurs threads simultanément sans provoquer de conflits.
Performance : L'interface Queue fournit des implémentations efficaces pour l'ajout, la suppression et l'inspection d'éléments, ce qui en fait un outil utile pour gérer des collections d'éléments dans les applications critiques en termes de performances.
Inconvénients de l'utilisation de l'interface Queue en Java :
Fonctionnalité limitée : L'interface Queue est conçue spécifiquement pour gérer des collections d'éléments dans un ordre spécifique, ce qui signifie qu'elle peut ne pas convenir à des structures de données ou à des algorithmes plus complexes.
Restrictions de taille : Certaines implémentations de l'interface Queue, comme la classe ArrayDeque, ont une taille fixe, ce qui signifie qu'elles ne peuvent pas dépasser un certain nombre d'éléments.
Utilisation de la mémoire: Selon l'implémentation, l'interface Queue peut nécessiter plus de mémoire que les autres structures de données, surtout si elle doit stocker des informations supplémentaires sur l'ordre des éléments.
Complexité : L'interface Queue peut être difficile à utiliser et à comprendre pour les programmeurs débutants, surtout s'ils ne sont pas familiers avec les principes des structures de données et des algorithmes.