Java ArrayDeque

En este tutorial, aprenderemos sobre la clase ArrayDeque y sus métodos con la ayuda de ejemplos. Además, aprenderemos a usar array deque para implementar una pila.

En Java, podemos usar el ArrayDeque clase para implementar estructuras de datos de cola y de cola utilizando matrices.

Interfaces implementadas por ArrayDeque

El ArrayDeque class implementa estas dos interfaces:

Interfaz de cola de Java
Interfaz Java Deque

Creando ArrayDeque

Para crear una matriz deque, debemos importar el java.util.ArrayDeque paquete.

Así es como podemos crear una matriz deque en Java:

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

Aquí, Escriba indica el tipo de la matriz deque. Por ejemplo,

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

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

Métodos de ArrayDeque

El ArrayDeque class proporciona implementaciones para todos los métodos presentes en Queue y Deque interfaz.

Insertar elementos en Deque

1. Agrega elementos usando add(), addFirst() y addLast()

add() - inserta el elemento especificado al final de la matriz deque
addFirst() - inserta el elemento especificado al principio de la matriz deque
addLast() - inserta el especificado al final de la matriz deque (equivalente a add() )

Nota: Si la matriz deque está llena, todos estos métodos add() , addFirst() y addLast() arroja IllegalStateException .

Por ejemplo,

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

Salida

ArrayDeque: [Cat, Dog, Horse]

2. Insertar elementos usando oferta(), ofertaprimero() y ofertaúltimo()

offer() - inserta el elemento especificado al final de la matriz deque
offerFirst() - inserta el elemento especificado al principio de la matriz deque
offerLast() - inserta el elemento especificado al final de la matriz deque

Nota: offer() , offerFirst() y offerLast() devuelve true si el elemento se inserta con éxito; si la matriz deque está llena, estos métodos devuelven false .

Por ejemplo,

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

Salida

ArrayDeque: [Cat, Dog, Horse]

Nota: Si la matriz deque está llena

el add() el método lanzará una excepción
el offer() método devuelve false

Acceso a elementos ArrayDeque

1. Acceda a elementos usando getFirst() y getLast()

getFirst() - devuelve el primer elemento de la matriz deque
getLast() - devuelve el último elemento de la matriz deque

Nota: Si la matriz deque está vacía, getFirst() y getLast() lanza NoSuchElementException .

Por ejemplo,

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

Salida

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

2. Acceda a los elementos usando los métodos peek(), peekFirst() y peekLast()

peek() - devuelve el primer elemento de la matriz deque
peekFirst() - devuelve el primer elemento de la matriz deque (equivalente a peek() )
peekLast() - devuelve el último elemento de la matriz deque

Por ejemplo,

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

Salida

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

Nota: Si la matriz deque está vacía, peek() , peekFirst() y getLast() lanza NoSuchElementException .

Eliminar elementos ArrayDeque

1. Elimina elementos usando el método remove(), removeFirst(), removeLast()

remove() - devuelve y elimina un elemento del primer elemento de la matriz deque
remove(element) - devuelve y elimina el elemento especificado del encabezado de la matriz deque
removeFirst() - devuelve y elimina el primer elemento de la matriz deque (equivalente a remove() )
removeLast() - devuelve y elimina el último elemento de la matriz deque

Nota: Si la matriz deque está vacía, remove() , removeFirst() y removeLast() método lanza una excepción. Además, remove(element) lanza una excepción si no se encuentra el elemento.

Por ejemplo,

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

Salida

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

2. Elimina elementos usando los métodos poll(), pollFirst() y pollLast()

poll() - devuelve y elimina el primer elemento de la matriz deque
pollFirst() - devuelve y elimina el primer elemento de la matriz deque (equivalente a poll() )
pollLast() - devuelve y elimina el último elemento de la matriz deque

Nota: Si la matriz deque está vacía, poll() , pollFirst() y pollLast() devuelve null si no se encuentra el elemento.

Por ejemplo,

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

Salida

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

3. Quitar Elemento:usando el método clear()

Para eliminar todos los elementos de la matriz deque, usamos el clear() método. Por ejemplo,

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

Salida

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

Iterando el ArrayDeque

iterator() - devuelve un iterador que se puede usar para iterar sobre la matriz deque
descendingIterator() - devuelve un iterador que se puede usar para iterar sobre la matriz deque en orden inverso

Para usar estos métodos, debemos importar el java.util.Iterator paquete. Por ejemplo,

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(", ");
        }
    }
}

Salida

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

Otros métodos

Métodos	Descripciones
`element()`	Retorna un elemento de la cabecera del arreglo deque.
`contains(element)`	Busca en la matriz deque el elemento especificado. Si se encuentra el elemento, devuelve `true` , si no, devuelve `false` .
`size()`	Devuelve la longitud de la matriz deque.
`toArray()`	Convierte el arreglo deque en arreglo y lo devuelve.
`clone()`	Crea una copia de la matriz deque y la devuelve.

ArrayDeque como una pila

Para implementar un LIFO (Last-In-First-Out) pilas en Java, se recomienda usar una deque sobre la clase Stack. El ArrayDeque Es probable que la clase sea más rápida que el Stack clase.

ArrayDeque proporciona los siguientes métodos que se pueden usar para implementar una pila.

push() - agrega un elemento a la parte superior de la pila
peek() - devuelve un elemento de la parte superior de la pila
pop() - devuelve y elimina un elemento de la parte superior de la pila

Por ejemplo,

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

Salida

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

ArrayDeque vs. Clase de lista enlazada

Ambos ArrayDeque y Java LinkedList implementa el Deque interfaz. Sin embargo, existen algunas diferencias entre ellos.

LinkedList admite null elementos, mientras que ArrayDeque no.
Cada nodo de una lista vinculada incluye vínculos a otros nodos. Por eso LinkedList requiere más almacenamiento que ArrayDeque .
Si está implementando la cola o la estructura de datos deque, un ArrayDeque es probable que sea más rápido que un LinkedList .

Java LinkedList Cola de bloqueo de Java

Java