ArrayDeque Java

Java ArrayDeque

Dans ce tutoriel, nous allons découvrir la classe ArrayDeque et ses méthodes à l'aide d'exemples. De plus, nous apprendrons à utiliser array deque pour implémenter une pile.

En Java, on peut utiliser le ArrayDeque classe pour implémenter les structures de données de file d'attente et de deque à l'aide de tableaux.

Interfaces implémentées par ArrayDeque

Le ArrayDeque class implémente ces deux interfaces :

Interface de file d'attente Java
Interface Java Deque

Création de ArrayDeque

Afin de créer un tableau deque, nous devons importer le java.util.ArrayDeque paquet.

Voici comment créer un tableau deque en Java :

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

Ici, Tapez indique le type du tableau deque. Par exemple,

// Creating String type ArrayDeque
ArrayDeque<String> animals = new ArrayDeque<>();

// Creating Integer type ArrayDeque
ArrayDeque<Integer> age = new ArrayDeque<>();

Méthodes de ArrayDeque

Le ArrayDeque la classe fournit des implémentations pour toutes les méthodes présentes dans Queue et Deque interface.

Insérer des éléments à Deque

1. Ajouter des éléments en utilisant add(), addFirst() et addLast()

add() - insère l'élément spécifié à la fin du tableau deque
addFirst() - insère l'élément spécifié au début du tableau deque
addLast() - insère le spécifié à la fin du tableau deque (équivalent à add() )

Remarque : Si le tableau deque est plein, toutes ces méthodes add() , addFirst() et addLast() lance IllegalStateException .

Par exemple,

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();

        // Using add()
        animals.add("Dog");

        // Using addFirst()
        animals.addFirst("Cat");

        // Using addLast()
        animals.addLast("Horse");
        System.out.println("ArrayDeque: " + animals);
    }
}

Sortie

ArrayDeque: [Cat, Dog, Horse]

2. Insérer des éléments en utilisant offre(), offrePremier() et offreLast()

offer() - insère l'élément spécifié à la fin du tableau deque
offerFirst() - insère l'élément spécifié au début du tableau deque
offerLast() - insère l'élément spécifié à la fin du tableau deque

Remarque : offer() , offerFirst() et offerLast() renvoie true si l'élément est inséré avec succès ; si le tableau deque est plein, ces méthodes renvoient false .

Par exemple,

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        // Using offer()
        animals.offer("Dog");

        // Using offerFirst()
        animals.offerFirst("Cat");

        // Using offerLast()
        animals.offerLast("Horse");
        System.out.println("ArrayDeque: " + animals);
    }
}

Sortie

ArrayDeque: [Cat, Dog, Horse]

Remarque : Si le tableau deque est plein

le add() méthode lèvera une exception
le offer() la méthode renvoie false

Accéder aux éléments ArrayDeque

1. Accéder aux éléments à l'aide de getFirst() et getLast()

getFirst() - renvoie le premier élément du tableau deque
getLast() - renvoie le dernier élément du tableau deque

Remarque : Si le tableau deque est vide, getFirst() et getLast() lance 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);

        // Get the first element
        String firstElement = animals.getFirst();
        System.out.println("First Element: " + firstElement);

        // Get the last element
        String lastElement = animals.getLast();
        System.out.println("Last Element: " + lastElement);
    }
}

Sortie

ArrayDeque: [Dog, Cat, Horse]
First Element: Dog
Last Element: Horse

2. Accéder aux éléments à l'aide des méthodes peek(), peekFirst() et peekLast()

peek() - renvoie le premier élément du tableau deque
peekFirst() - renvoie le premier élément du tableau deque (équivalent à peek() )
peekLast() - renvoie le dernier élément du tableau deque

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);

        // Using peek()
        String element = animals.peek();
        System.out.println("Head Element: " + element);

        // Using peekFirst()
        String firstElement = animals.peekFirst();
        System.out.println("First Element: " + firstElement);

        // Using peekLast
        String lastElement = animals.peekLast();
        System.out.println("Last Element: " + lastElement);
    }
}

Sortie

ArrayDeque: [Dog, Cat, Horse]
Head Element: Dog
First Element: Dog
Last Element: Horse

Remarque : Si le tableau deque est vide, peek() , peekFirst() et getLast() jette NoSuchElementException .

Supprimer les éléments ArrayDeque

1. Supprimez des éléments à l'aide de la méthode remove(), removeFirst(), removeLast()

remove() - renvoie et supprime un élément du premier élément du tableau deque
remove(element) - renvoie et supprime l'élément spécifié de la tête du tableau deque
removeFirst() - renvoie et supprime le premier élément du tableau deque (équivalent à remove() )
removeLast() - renvoie et supprime le dernier élément du tableau deque

Remarque : Si le tableau deque est vide, remove() , removeFirst() et removeLast() méthode lève une exception. Aussi, remove(element) lève une exception si l'élément n'est pas trouvé.

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);

        // Using remove()
        String element = animals.remove();
        System.out.println("Removed Element: " + element);

        System.out.println("New ArrayDeque: " + animals);

        // Using removeFirst()
        String firstElement = animals.removeFirst();
        System.out.println("Removed First Element: " + firstElement);

        // Using removeLast()
        String lastElement = animals.removeLast();
        System.out.println("Removed Last Element: " + lastElement);
    }
}

Sortie

ArrayDeque: [Dog, Cat, Cow, Horse]
Removed Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Removed First Element: Cat
Removed Last Element: Horse

2. Supprimez des éléments à l'aide des méthodes poll(), pollFirst() et pollLast()

poll() - renvoie et supprime le premier élément du tableau deque
pollFirst() - renvoie et supprime le premier élément du tableau deque (équivalent à poll() )
pollLast() - renvoie et supprime le dernier élément du tableau deque

Remarque : Si le tableau deque est vide, poll() , pollFirst() et pollLast() renvoie null si l'élément n'est pas trouvé.

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);

        // Using poll()
        String element = animals.poll();
        System.out.println("Removed Element: " + element);
        System.out.println("New ArrayDeque: " + animals);

        // Using pollFirst()
        String firstElement = animals.pollFirst();
        System.out.println("Removed First Element: " + firstElement);

        // Using pollLast()
        String lastElement = animals.pollLast();
        System.out.println("Removed Last Element: " + lastElement);
    }
}

Sortie

ArrayDeque: [Dog, Cat, Cow, Horse]
Removed Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Removed First Element: Cat
Removed Last Element: Horse

3. Supprimer l'élément :en utilisant la méthode clear()

Pour supprimer tous les éléments du tableau deque, on utilise le clear() méthode. 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);

        // Using clear()
        animals.clear();

        System.out.println("New ArrayDeque: " + animals);
    }
}

Sortie

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

Itérer le ArrayDeque

iterator() - renvoie un itérateur qui peut être utilisé pour parcourir le tableau deque
descendingIterator() - renvoie un itérateur qui peut être utilisé pour parcourir le tableau deque dans l'ordre inverse

Pour utiliser ces méthodes, nous devons importer le java.util.Iterator forfait. Par exemple,

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("\nArrayDeque in reverse order: ");
        // Using descendingIterator()
        Iterator<String> desIterate = animals.descendingIterator();
        while(desIterate.hasNext()) {
            System.out.print(desIterate.next());
            System.out.print(", ");
        }
    }
}

Sortie

ArrayDeque: [Dog, Cat, Horse]
ArrayDeque in reverse order: [Horse, Cat, Dog]

Autres méthodes

Méthodes	Descriptions
`element()`	Renvoie un élément de la tête du tableau deque.
`contains(element)`	Recherche dans le tableau deque l'élément spécifié. Si l'élément est trouvé, il renvoie `true` , sinon il renvoie `false` .
`size()`	Renvoie la longueur du tableau deque.
`toArray()`	Convertit le tableau deque en tableau et le renvoie.
`clone()`	Crée une copie du tableau deque et la renvoie.

ArrayDeque en tant que pile

Pour implémenter un LIFO (Last-In-First-Out) piles en Java, il est recommandé d'utiliser un deque sur la classe Stack. Le ArrayDeque classe est susceptible d'être plus rapide que le Stack classe.

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

push() - ajoute un élément en haut de la pile
peek() - renvoie un élément du haut de la pile
pop() - renvoie et supprime un élément du haut de la pile

Par exemple,

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> stack = new ArrayDeque<>();

        // Add elements to stack
        stack.push("Dog");
        stack.push("Cat");
        stack.push("Horse");
        System.out.println("Stack: " + stack);

        // Access element from top of stack
        String element = stack.peek();
        System.out.println("Accessed Element: " + element);

        // Remove elements from top of stack
        String remElement = stack.pop();
        System.out.println("Removed element: " + remElement);
    }
}

Sortie

Stack: [Horse, Cat, Dog]
Accessed Element: Horse
Removed Element: Horse

ArrayDeque Vs. Classe LinkedList

Les deux ArrayDeque et Java LinkedList implémente le Deque interface. Cependant, il existe quelques différences entre eux.

LinkedList prend en charge null éléments, alors que ArrayDeque pas.
Chaque nœud d'une liste chaînée inclut des liens vers d'autres nœuds. C'est pourquoi LinkedList nécessite plus de stockage que ArrayDeque .
Si vous implémentez la file d'attente ou la structure de données deque, un ArrayDeque est probablement plus rapide qu'un LinkedList .

Liste liée Java File d'attente de blocage Java

Java