java queue queue methods
Dans ce didacticiel, nous discuterons de ce qu'est une file d'attente en Java, de son utilisation, de l'exemple de file d'attente Java, des méthodes de file d'attente Java et de l'implémentation de l'interface de file d'attente:
Une file d'attente est une structure de données linéaire ou une collection en Java qui stocke des éléments dans un ordre FIFO (premier entré, premier sorti).
La collection de files d'attente a deux extrémités, à savoir avant et arrière. Les éléments sont ajoutés à l'arrière et retirés de l'avant.
comment ouvrir un fichier apk dans windows
=> Visitez ici pour voir la série de formations Java pour tous.
Ce que vous apprendrez:
Qu'est-ce qu'une file d'attente Java?
Une structure de données de file d'attente est représentée comme indiqué ci-dessous:
Comme le montre le diagramme ci-dessus, une file d'attente est une structure ayant deux points, c'est-à-dire le début (avant) et la fin (arrière). Les éléments sont insérés dans la file d'attente à l'arrière et retirés de la file d'attente à l'avant.
En Java, Queue est une interface qui fait partie du package java.util. L'interface de file d'attente étend l'interface Java Collection.
La définition générale de l'interface de file d'attente est:
public interface Queue extends CollectionComme la file d'attente est une interface, elle ne peut pas être instanciée. Nous avons besoin de quelques classes concrètes pour implémenter la fonctionnalité de l'interface Queue. Deux classes implémentent l'interface Queue, à savoir LinkedList et PriorityQueue.
Voici quelques-unes des principales caractéristiques de la structure de données de file d'attente:
- La file d'attente suit l'ordre FIFO (premier entré, premier sorti). Cela signifie que l'élément est inséré dans la file d'attente à la fin et supprimé de la file d'attente au début.
- L'interface de file d'attente Java fournit toutes les méthodes de l'interface de collection telles que l'insertion, la suppression, etc.
- LinkedList et PriorityQueue sont les classes qui implémentent l'interface Queue. ArrayBlockingQueue est encore une autre classe qui implémente l'interface Queue.
- Les files d'attente qui font partie du package java.util peuvent être classées comme des files d'attente illimitées tandis que celles présentes dans java.util.the package simultané sont des files d'attente limitées.
- Le Deque est une file d'attente qui prend en charge l'insertion et la suppression des deux extrémités.
- Le deque est thread-safe.
- Les BlockingQueues sont thread-safe et sont utilisées pour implémenter des problèmes producteur-consommateur.
- BlockingQueues n'autorise pas les éléments nuls. Une NullPointerException est levée si une opération liée à des valeurs nulles est tentée.
Comment utiliser une file d'attente en Java?
Pour utiliser une file d'attente en Java, nous devons d'abord importer l'interface de file d'attente comme suit:
import java.util.queue; Ou
import java.util.*; Une fois celui-ci importé, nous pouvons créer une file d'attente comme indiqué ci-dessous:
Queue str_queue = new LinkedList (); Comme Queue est une interface, nous utilisons une classe LinkedList qui implémente l'interface Queue pour créer un objet queue.
De même, nous pouvons créer une file d'attente avec d'autres classes concrètes.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Maintenant que l'objet queue est créé, nous pouvons initialiser l'objet queue en lui fournissant les valeurs via la méthode add comme indiqué ci-dessous.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Exemple de file d'attente Java
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue str_queue = new LinkedList(); //initialize the queue with values str_queue.add('one'); str_queue.add('two'); str_queue.add('three'); str_queue.add('four'); //print the Queue System.out.println('The Queue contents:' + str_queue); } }Production:
Le contenu de la file d'attente: (un, deux, trois, quatre)
L'exemple ci-dessus montre la déclaration et l'initialisation d'un objet Queue. Ensuite, nous imprimons simplement le contenu de la file d'attente.
Méthodes de file d'attente en Java
Dans cette section, nous discuterons des méthodes d'API pour la file d'attente. L'interface de file d'attente prend en charge diverses opérations comme l'insertion, la suppression, l'aperçu, etc. Certaines opérations déclenchent une exception tandis que d'autres renvoient une valeur spécifique lorsque la méthode réussit ou échoue.
Notez qu'il n'y a pas de modifications spécifiques à la collection Queue dans Java 8. Les méthodes ci-dessous sont également disponibles dans les versions ultérieures de Java comme Java 9, etc.
Le tableau ci-dessous résume toutes ces méthodes.
| Méthode | Prototype de méthode | Description |
|---|---|---|
| Taille | taille int () | Renvoie la taille ou le nombre d'éléments dans la file d'attente. |
| ajouter | booléen ajouter (E e) | Ajoute l'élément e à la file d'attente à la fin (queue) de la file d'attente sans violer les restrictions sur la capacité. Renvoie true en cas de succès ou IllegalStateException si la capacité est épuisée. |
| coup d'oeil | E coup d'oeil () | Renvoie la tête (avant) de la file d'attente sans la supprimer. |
| élément | Élément E () | Effectue la même opération que la méthode peek (). Lève NoSuchElementException lorsque la file d'attente est vide. |
| supprimer | E supprimer () | Supprime la tête de la file d'attente et la renvoie. Lève NoSuchElementException si la file d'attente est vide. |
| sondage | Sondage E () | Supprime la tête de la file d'attente et la renvoie. Si la file d'attente est vide, elle renvoie null. |
| Offre | offre booléenne (E e) | Insérez le nouvel élément e dans la file d'attente sans violer les restrictions de capacité. |
Itération des éléments de la file d'attente
Nous pouvons parcourir les éléments de la file d'attente en utilisant la boucle forEach ou en utilisant un itérateur. Le programme donné ci-dessous implémente les deux approches pour traverser la file d'attente.
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue LL_queue = new LinkedList(); //initialize the Queue LL_queue.add('Value-0'); LL_queue.add('Value-1'); LL_queue.add('Value-2'); LL_queue.add('Value-3'); //traverse the Queue using Iterator System.out.println('The Queue elements through iterator:'); Iterator iterator = LL_queue.iterator(); while(iterator.hasNext()){ String element = (String) iterator.next(); System.out.print(element + ' '); } System.out.println('
The Queue elements using for loop:'); //use new for loop to traverse the Queue for(Object object : LL_queue) { String element = (String) object; System.out.print(element + ' '); } } }Production:
Les éléments de la file d'attente via l'itérateur:
Valeur-0 Valeur-1 Valeur-2 Valeur-3
Les éléments Queue utilisant la boucle for:
Valeur-0 Valeur-1 Valeur-2 Valeur-3
Implémentation de file d'attente Java
Le programme ci-dessous montre les méthodes dont nous avons discuté ci-dessus.
import java.util.*; public class Main { public static void main(String() args) { Queue q1 = new LinkedList(); //Add elements to the Queue q1.add(10); q1.add(20); q1.add(30); q1.add(40); q1.add(50); System.out.println('Elements in Queue:'+q1); //remove () method =>removes first element from the queue System.out.println('Element removed from the queue: '+q1.remove()); //element() => returns head of the queue System.out.println('Head of the queue: '+q1.element()); //poll () => removes and returns the head System.out.println('Poll():Returned Head of the queue: '+q1.poll()); //returns head of the queue System.out.println('peek():Head of the queue: '+q1.peek()); //print the contents of the Queue System.out.println('Final Queue:'+q1); } } Production:
Éléments de la file d'attente: (10, 20, 30, 40, 50)
Élément retiré de la file d'attente: 10
Tête de file: 20
Sondage (): Retour en tête de la file d'attente: 20
peek (): Tête de file: 30
File d'attente finale: (30, 40, 50)
meilleur programme pour masquer l'adresse IP
Implémentation Java Queue Array
L'implémentation de file d'attente n'est pas aussi simple qu'une implémentation de pile. Tout d'abord, la file d'attente contient deux pointeurs, arrière et avant. En outre, différentes opérations sont effectuées à deux extrémités différentes.
Pour implémenter la file d'attente à l'aide de tableaux, nous déclarons d'abord un tableau qui contiendra n nombre d'éléments de file d'attente.
Ensuite, nous définissons les opérations suivantes à effectuer dans cette file d'attente.
# 1) Mettre en file d'attente: Une opération pour insérer un élément dans la file d'attente est Enqueue (fonction queueEnqueue dans le programme). Pour insérer un élément à l'arrière, nous devons d'abord vérifier si la file d'attente est pleine. S'il est plein, nous ne pouvons pas insérer l'élément. Si arrière # 2) Dequeue: L'opération pour supprimer un élément de la file d'attente est Dequeue (fonction queueDequeue dans le programme). Tout d'abord, nous vérifions si la file d'attente est vide. Pour que l'opération de retrait de la file d'attente fonctionne, il doit y avoir au moins un élément dans la file d'attente. # 3) Avant: Cette méthode retourne le début de la file d'attente. # 4) Affichage: Cette méthode parcourt la file d'attente et affiche les éléments de la file d'attente. Le programme Java suivant illustre l'implémentation Array de Queue. Production: File d'attente initiale: Comme nous avons implémenté la structure de données de la file d'attente à l'aide de tableaux dans le programme ci-dessus, nous pouvons également implémenter la file d'attente à l'aide de la liste liée. Nous implémenterons les mêmes méthodes de mise en file d'attente, de retrait de la file d'attente, de mise en avant et d'affichage dans ce programme. La différence est que nous utiliserons la structure de données Linked List au lieu de Array. Le programme ci-dessous illustre l'implémentation de la liste liée de Queue en Java. Production: Élément 6 ajouté à la file d'attente BlockingQueue est une interface ajoutée à Java 1.5 et fait partie du java.util.concurrent paquet. Cette interface introduit le blocage au cas où la BlockingQueue est pleine ou vide. Ainsi, lorsqu'un thread accède à la file d'attente et tente d'insérer (mettre en file d'attente) des éléments dans une file d'attente déjà pleine, il est bloqué jusqu'à ce qu'un autre thread crée un espace dans la file d'attente (peut-être par une opération de retrait de la file d'attente ou par effacement de la file d'attente). De même, dans le cas d'un retrait de la file d'attente, l'opération est bloquée si la file d'attente est vide jusqu'à ce que l'élément devienne disponible pour l'opération de retrait de la file d'attente. Les méthodes BlockingQueue utilisent une forme de contrôle d'accès concurrentiel comme les verrous internes et sont atomiques. BlockingQueue est une file d'attente simultanée qui gère les opérations de file d'attente simultanément. La BlockingQueue est illustrée ci-dessous: Notez que BlockingQueue n'accepte pas les valeurs nulles. Une tentative d'insertion d'une valeur nulle dans la file d'attente entraîne NullPointerException. Certaines des implémentations de BlockingQueue fournies en Java sont LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue et SynchonousQueue. Toutes ces implémentations sont thread-safe. Les BlockingQueues sont de deux types: Dans la file d'attente limitée, la capacité de la file d'attente est transmise au constructeur de la file d'attente. La déclaration de file d'attente est la suivante: BlockingQueue blockingQueue = new LinkedBlockingDeque (5); Dans la file d'attente illimitée, nous ne définissons pas la capacité de la file d'attente de manière explicite et sa taille peut augmenter. La capacité est définie sur Integer.MAX_VALUE. La déclaration de la file d'attente illimitée est la suivante: BlockingQueue blockingQueue = new LinkedBlockingDeque (); L'interface BlockingQueue est principalement utilisée pour les types de problèmes producteur-consommateur dans lesquels le producteur produit les ressources et le consommateur consomme les ressources. Q # 1) Qu'est-ce qu'une file d'attente en Java? Répondre: La file d'attente en Java est une structure de données ordonnée linéaire qui suit l'ordre FIFO (premier entré, premier sorti) des éléments. Cela signifie que l'élément inséré en premier dans la file d'attente sera le premier élément à être supprimé. En Java, la file d'attente est implémentée comme une interface qui hérite de l'interface Collection. Q # 2) Un Java thread-safe de file d'attente est-il? Répondre: Toutes les files d'attente ne sont pas thread-safe, mais les BlockingQueues en Java sont thread-safe. Q # 3) Qu'est-ce qui est le plus rapide - Pile ou file d'attente? Répondre: La pile est plus rapide. Dans la pile, les éléments sont traités à partir d'une seule extrémité, donc aucun décalage n'est nécessaire. Mais dans la file d'attente, les éléments doivent être décalés et ajustés car il existe deux pointeurs différents pour insérer et supprimer des éléments. Q # 4) Quels sont les types de file d'attente? Réponse: Les files d'attente sont des types suivants: Q # 5) Pourquoi la file d'attente est-elle utilisée? Répondre: La structure des données de la file d'attente est utilisée à des fins de synchronisation. La file d'attente est également utilisée pour la planification du disque et du processeur. Dans ce didacticiel, nous avons discuté des files d'attente simples avec leurs détails tels que les déclarations, l'implémentation d'initialisation et les méthodes. Nous avons également découvert l'implémentation Array et LinkedList de Queue en Java. Dans nos prochains didacticiels, nous aborderons plus en détail d'autres types de files d'attente. => Consultez TOUS les didacticiels Java ici. class Queue { private static int front, rear, capacity; private static int queue(); Queue(int size) { front = rear = 0; capacity = size; queue = new int(capacity); } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue(rear) = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
'); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i
La file d'attente est vide
File d'attente après l'opération de mise en file d'attente:
10 = 30 = 50 = 70 =
Élément avant de la file d'attente: 10
La file d'attente est pleine
10 = 30 = 50 = 70 =
File d'attente après deux opérations de retrait de la file d'attente: 50 = 70 =
Élément avant de la file d'attente: 50
Implémentation de liste liée Java Queue
class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class Main{ public static void main(String a()){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } }
Élément 3 ajouté à la file d'attente
Avant de la file d'attente: 6 Arrière de la file d'attente: 3
Élément 12 ajouté à la file d'attente
Élément 24 ajouté à la file d'attente
Élément 6 retiré de la file d'attente
Élément 3 retiré de la file d'attente
Élément 9 ajouté à la file d'attente
Avant de la file d'attente: 12 Arrière de la file d'attente: 9
BlockingQueue en Java
Que fait la phase de vérification dans le cycle de vie du logiciel?
Types de file d'attente de blocage
File d'attente limitée
File d'attente illimitée
Questions fréquemment posées
Conclusion
lecture recommandée