Java ArrayDeque

Dans ce tutoriel, nous allons apprendre la classe ArrayDeque et ses méthodes à l'aide d'exemples. De plus, nous allons également apprendre à utiliser ArrayDeque pour réaliser des piles.

En Java, nous pouvons utiliser la classe ArrayDeque pour réaliser les structures de données de file et de file doublement allouée à l'aide d'un tableau.

Les interfaces implémentées par ArrayDeque

La classe ArrayDeque implémente ces deux interfaces :

• Interface Queue Java

• Java Deque interface

Créer ArrayDeque

Pour créer une file doublement allouée ArrayDeque, nous devons importer le paquet java.util.ArrayDeque.

Voici les méthodes que nous pouvons utiliser en Java pour créer une file doublement allouée ArrayDeque :

ArrayDeque<Type> animal = new ArrayDeque<>();

Ici, Type représente le type de la file doublement allouée ArrayDeque. Par exemple,

//Créer une ArrayDeque de type chaîne
ArrayDeque<String> animals = new ArrayDeque<>();
//Créer une ArrayDeque de type entier
ArrayDeque<Integer> age = new ArrayDeque<>();

Méthodes ArrayDeque

La classe ArrayDeque fournit toutes les méthodes existantes de l'interface Queue et Deque.

Insérer l'élément dans la file doublement allouée

1.Utiliser add(), addFirst() et addLast() pour ajouter des éléments

• add() - Insère l'élément spécifié à la fin de la file doublement chainée ArrayDeque

• addFirst() -Insérer l'élément spécifié au début de la file doublement allouée ArrayDeque

• addLast() - Insérer le contenu spécifié à la fin de la file doublement allouée ArrayDeque (équivalent à add())

Attention :Si la file doublement allouée ArrayDeque est pleine, toutes ces méthodes add(), addFirst() et addLast() déclencheront IllegalStateException.

Par exemple,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　//Utiliser add　()
　　　　　　　　animals.add("Dog");
　　　　　　　　//Utiliser addFirst　()
　　　　　　　　Utiliser addFirst()
　　　　　　　　//Utiliser addLast()
　　　　　　　　animals.addLast("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　}
}

Output result

ArrayDeque : [Chat, Chien, Cheval]

2.Utiliser offer(), offerFirst() et offerLast() pour insérer des éléments

• offer() - Insère l'élément spécifié à la fin de la file doublement chainée ArrayDeque

• offerFirst() - Insère l'élément spécifié au début de la file doublement chainée ArrayDeque

• offerLast() - Insère l'élément spécifié à la fin de la file doublement chainée ArrayDeque

Attention : offer(), offerFirst() et offerLast() retournent true si l'insertion a réussi ; sinon, ils retournent. Si la file doublement chainée ArrayDeque est pleine, ces méthodes retournent false.

Par exemple,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　//Utilisation de offer()
　　　　　　　　animals.offer("Chien");
　　　　　　　　//Utilisation de offerFirst()
　　　　　　　　animals.offerFirst("Chat");
　　　　　　　　//Utilisation de offerLast()
　　　　　　　　animals.offerLast("Cheval");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　}
}

Output result

ArrayDeque : [Chat, Chien, Cheval]

Accéder aux éléments de ArrayDeque

1.Utilisation de getFirst() et getLast() pour accéder aux éléments

• getFirst() - Retourne l'élément premier de la file doublement chainée ArrayDeque

• getLast() - Retourne l'élément dernier de la file doublement chainée ArrayDeque

Remarque :Si la file doublement chainée ArrayDeque est vide, getFirst() et getLast() lancent une NoSuchElementException.

Par exemple,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　　　　　//　Obtenir l'élément premier
　　　　　　　　String firstElement = animals.getFirst();
　　　　　　　　System.out.println("Premier élément : "　+　firstElement);
　　　　　　　　//Obtenir l'élément dernier
　　　　　　　　String lastElement = animals.getLast();
　　　　　　　　System.out.println("Dernier élément : "　+　lastElement);
　　　　}
}

Output result

ArrayDeque : [Dog, Cat, Horse]
Premier élément : Dog
Dernier élément : Horse

2.Utilisation des méthodes peek(), peekFirst() et peekLast() pour accéder aux éléments

• peek() - Retourne l'élément premier de la file doublement chainée ArrayDeque

• peekFirst() - Retourne l'élément premier de la file doublement chainée ArrayDeque (équivalent à peek())

• peekLast() - Retourne l'élément dernier de la file doublement chainée ArrayDeque

Par exemple,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　　　　　//Utilisation de peek()
　　　　　　　　String element = animals.peek();
　　　　　　　　System.out.println("Élément de tête : "　+　element);
　　　　　　　　//Utilisation de peekFirst()
　　　　　　　　String firstElement = animals.peekFirst();
　　　　　　　　System.out.println("Premier élément : "　+　firstElement);
　　　　　　　　//Utilisation de peekLast
　　　　　　　　String lastElement = animals.peekLast();
　　　　　　　　System.out.println("Dernier élément : "　+　lastElement);
　　　　}
}

Output result

ArrayDeque : [Dog, Cat, Horse]
Élément d'en-tête : Dog
Premier élément : Dog
Dernier élément : Horse

Attention :Si la file doublement chaînée ArrayDeque est vide, peek(), peekFirst() et getLast() lancent NoSuchElementException.

Suppression des éléments ArrayDeque

1.Utilisez les méthodes remove(), removeFirst(), removeLast() pour supprimer des éléments

• remove() - Retournez et supprimez un élément de l'élément premier de la file doublement chaînée ArrayDeque

• remove(element) - Retournez et supprimez l'élément spécifié à partir du début de la file doublement chaînée ArrayDeque

• removeFirst() - Retournez et supprimez l'élément premier de la file doublement chaînée ArrayDeque (équivalent à remove())

• removeLast() - Retournez et supprimez l'élément dernier de la file doublement chaînée ArrayDeque

Attention :Si la file doublement chaînée ArrayDeque est vide, les méthodes remove(), removeFirst() et removeLast() lèvent une exception. De plus, si l'élément recherché n'est pas trouvé, remove(element) lève une exception.

Par exemple,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　　　　　//Utilisez remove()
　　　　　　　　String element = animals.remove();
　　　　　　　　System.out.println("Suppression de l'élément: "")　+　element);
　　　　　　　　System.out.println("New ArrayDeque: ");　+　animals);
　　　　　　　　//Utilisez removeFirst()
　　　　　　　　String firstElement = animals.removeFirst();
　　　　　　　　System.out.println("Remove the first element: ");　+　firstElement);
　　　　　　　　//Utilisez removeLast()
　　　　　　　　String lastElement = animals.removeLast();
　　　　　　　　System.out.println("Remove the last element: ");　+　lastElement);
　　　　}
}

Output result

ArrayDeque: [Dog, Cat, Cow, Horse]
Remove Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Remove the first element: Cat
Remove the last element: Horse

2.Utilisez les méthodes poll(), pollFirst() et pollLast() pour supprimer des éléments

• poll() - Retournez et supprimez l'élément premier de la file doublement chaînée ArrayDeque

• pollFirst() - Retournez et supprimez l'élément premier de la file doublement chaînée ArrayDeque (équivalent à poll())

• pollLast() - Retournez et supprimez l'élément dernier de la file doublement chaînée ArrayDeque

Attention :Si la file doublement chaînée ArrayDeque est vide, si l'élément recherché n'est pas trouvé, poll(), pollFirst() et pollLast() renvoient null.

Par exemple,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　　　　　//Utilisez poll()
　　　　　　　　String element = animals.poll();
　　　　　　　　System.out.println("Suppression de l'élément: "")　+　element);
　　　　　　　　System.out.println("New ArrayDeque: ");　+　animals);
　　　　　　　　//Utilisez pollFirst()
　　　　　　　　String firstElement = animals.pollFirst();
　　　　　　　　System.out.println("Remove the first element: ");　+　firstElement);
　　　　　　　　//Using pollLast()
　　　　　　　　String lastElement = animals.pollLast();
　　　　　　　　System.out.println("Remove the last element: ");　+　lastElement);
　　　　}
}

Output result

ArrayDeque: [Dog, Cat, Cow, Horse]
Remove Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Remove the first element: Cat
Remove the last element: Horse

3. Remove element: Using clear() method

To remove all elements from the ArrayDeque deque, we use the clear() method. For example,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　　　　　//Using clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("New ArrayDeque: ");　+　animals);
　　　　}
}

Output result

ArrayDeque : [Dog, Cat, Horse]
New ArrayDeque: []

Iterate over the ArrayDeque

• iterator() - Returns an iterator that can be used to traverse the ArrayDeque deque

• descendingIterator() -Returns an iterator that can be used to traverse the ArrayDeque deque in reverse order

To use these methods, we must import the java.util.Iterator package. For example,

import java.util.ArrayDeque;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.print("ArrayDeque: ");
　　　　　　　　//Using iterator()
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　System.out.print("\nReverse ArrayDeque: ");
　　　　　　　　//Utilisez descendingIterator()}
　　　　　　　　Iterator<String> desIterate = animals.descendingIterator();
　　　　　　　　while(desIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(desIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output result

ArrayDeque : [Dog, Cat, Horse]
ArrayDeque inversé : [Horse, Cat, Dog]

Autres méthodes

Utilisez ArrayDeque comme pile

Pour implémenter une pile en JavaLIFO (last in, first out)Pile, il est recommandé d'utiliserClasse StackUtilisez une file doublement chainée. L'ArrayDeque est plus rapide que la classe Stack.

ArrayDeque fournit les méthodes suivantes qui peuvent être utilisées pour implémenter une pile.

• push() - Ajouter un élément sur la pile en haut

• peek() - Retourner un élément de la pile en haut

• pop() - Retourner et supprimer l'élément en haut de la pile

Par exemple,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> stack = new ArrayDeque<>();
　　　　　　　　//Ajouter l'élément à la pile
　　　　　　　　stack.push("Dog");
　　　　　　　　stack.push("Cat");
　　　　　　　　stack.push("Horse");
　　　　　　　　System.out.println("Pile : ")　+　stack);
　　　　　　　　//Accéder à l'élément en haut de la pile
　　　　　　　　String element = stack.peek();
　　　　　　　　System.out.println("Accès à l'élément : ")　+　element);
　　　　　　　　//Delete element from the top of the stack
　　　　　　　　String remElement = stack.pop();
　　　　　　　　System.out.println("Delete element: ",　+　remElement);
　　　　}
}

Output result

Stack: [Horse, Cat, Dog]
Access element: Horse
Delete Element: Horse

ArrayDeque with LinkedList class

ArrayDeque andJava's LinkedList allIt implements the Deque interface. However, there are some differences between them.

• LinkedList supports empty elements, while ArrayDeque does not.

• Each node in the linked list contains a link to another node. This is why LinkedList requires more storage space than ArrayDeque.

• If you need to implement a queue or deque data structure, ArrayDeque may be faster than LinkedList.