ArrayDeque de Java

En este tutorial, aprenderemos la clase ArrayDeque y sus métodos a través de ejemplos. Además, también aprenderemos a implementar pilas utilizando ArrayDeque.

En Java, podemos usar la clase ArrayDeque para implementar estructuras de datos de cola y cola de doble final utilizando arrays.

Interfaz implementada por ArrayDeque

La clase ArrayDeque implementa estas dos interfaces:

• Interfaz Queue de Java

• Java interfaz Deque

Crear ArrayDeque

Para crear una cola de doble final ArrayDeque, debemos importar el paquete java.util.ArrayDeque.

Estos son los métodos que podemos usar en Java para crear una cola de doble final ArrayDeque:

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

Aquí, Type representa el tipo de cola de doble final ArrayDeque. Por ejemplo,

//Crear ArrayDeque de tipo cadena
ArrayDeque<String> animals = new ArrayDeque<>();
//Crear ArrayDeque de tipo entero
ArrayDeque<Integer> age = new ArrayDeque<>();

Métodos de ArrayDeque

La clase ArrayDeque proporciona todos los métodos que existen en las interfaces Queue y Deque.

Insertar el elemento en la cola de doble final

1.Se utiliza add(), addFirst() y addLast() para agregar elementos

• add() - Insertar el elemento especificado al final de la cola de doble final ArrayDeque

• addFirst() -Insertar el elemento especificado al principio de la cola de doble final ArrayDeque

• addLast() - Insertar el contenido especificado al final de la cola de doble final ArrayDeque (equivalente a add())

Nota:Si la cola de doble final ArrayDeque está llena, todos estos métodos add(), addFirst() y addLast() lanzarán IllegalStateException.

Por ejemplo,

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

resultado de salida

ArrayDeque: [Gato, Perro, Caballo]

2.Se utiliza offer(), offerFirst() y offerLast() para insertar elementos

• offer() - Insertar el elemento especificado al final de la cola de doble final ArrayDeque

• offerFirst() - Insertar el elemento especificado en el principio de la cola de doble final ArrayDeque

• offerLast() - Insertar el elemento especificado al final de la cola de doble final ArrayDeque

Nota: offer(), offerFirst() y offerLast() devuelven true si se inserta correctamente el elemento; de lo contrario, devuelven. Si la cola de doble final ArrayDeque 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<>();
　　　　　　　　//Usar offer()
　　　　　　　　animals.offer("Perro");
　　　　　　　　//Usar offerFirst()
　　　　　　　　animals.offerFirst("Gato");
　　　　　　　　//Usar offerLast()
　　　　　　　　animals.offerLast("Caballo");
　　　　　　　　System.out.println("ArrayDeque:　"　+　animals);
　　　　}
}

resultado de salida

ArrayDeque: [Gato, Perro, Caballo]

Acceder a los elementos de ArrayDeque

1.Usar getFirst() y getLast() para acceder a los elementos

• getFirst() - Devuelve el primer elemento de la cola de doble final ArrayDeque

• getLast() - Devuelve el último elemento de la cola de doble final ArrayDeque

Nota:Si la cola de doble final ArrayDeque está vacía, getFirst() y getLast() lanzan 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);
　　　　　　　　//　Obtener el primer elemento
　　　　　　　　String firstElement = animals.getFirst();
　　　　　　　　System.out.println("El primer elemento: "　+　firstElement);
　　　　　　　　//Obtener el último elemento
　　　　　　　　String lastElement = animals.getLast();
　　　　　　　　System.out.println("El último elemento: "　+　lastElement);
　　　　}
}

resultado de salida

Cola doble: [Perro, Gato, Caballo]
Primer elemento: Dog
Último elemento: Horse

2.Usar peek(), peekFirst() y peekLast() para acceder a los elementos

• peek() - Devuelve el primer elemento de la cola de doble final ArrayDeque

• peekFirst() - Devuelve el primer elemento de la cola de doble final ArrayDeque (equivalente a peek())

• peekLast() - Devuelve el último elemento de la cola de doble final ArrayDeque

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);
　　　　　　　　//Usar peek()
　　　　　　　　String element = animals.peek();
　　　　　　　　System.out.println("El elemento de la cabeza: "　+　element);
　　　　　　　　//Usar peekFirst()
　　　　　　　　String firstElement = animals.peekFirst();
　　　　　　　　System.out.println("El primer elemento: "　+　firstElement);
　　　　　　　　//Usar peekLast
　　　　　　　　String lastElement = animals.peekLast();
　　　　　　　　System.out.println("El último elemento: "　+　lastElement);
　　　　}
}

resultado de salida

Cola doble: [Perro, Gato, Caballo]
Elemento de cabeza: Dog
Primer elemento: Dog
Último elemento: Horse

Nota:Si la cola de dos extremos ArrayDeque está vacía, peek(), peekFirst() y getLast() lanzan NoSuchElementException.

Eliminar elemento de ArrayDeque

1.Utilice los métodos remove(), removeFirst(), removeLast() para eliminar elementos

• remove() - Devuelve y elimina un elemento de la primera posición de la cola de dos extremos ArrayDeque

• remove(element) - Devuelve y elimina el elemento especificado desde la cabeza de la cola de dos extremos ArrayDeque

• removeFirst() - Devuelve y elimina el primer elemento de la cola de dos extremos ArrayDeque (equivalente a remove())

• removeLast() - Devuelve y elimina el último elemento de la cola de dos extremos ArrayDeque

Nota:Si la cola de dos extremos del array está vacía, los métodos remove(), removeFirst() y removeLast() lanzarán una excepción. Además, si no se encuentra el elemento, remove(element) lanzará una excepción.

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("Vaca");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque:　"　+　animals);
　　　　　　　　//Utilice remove()
　　　　　　　　String element = animals.remove();
　　　　　　　　System.out.println("Eliminar Elemento: ")　+　element);
　　　　　　　　System.out.println("Nuevo ArrayDeque:　"　+　animals);
　　　　　　　　//Utilice removeFirst()
　　　　　　　　String firstElement = animals.removeFirst();
　　　　　　　　System.out.println("Eliminar el primer elemento:　"　+　firstElement);
　　　　　　　　//Utilice removeLast()
　　　　　　　　String lastElement = animals.removeLast();
　　　　　　　　System.out.println("Eliminar el último elemento:　"　+　lastElement);
　　　　}
}

resultado de salida

ArrayDeque:　[Dog,　Cat,　Cow,　Horse]
Eliminar Elemento:　Dog
Nuevo ArrayDeque:　[Cat,　Cow,　Horse]
Eliminar el primer elemento:　Cat
Eliminar el último elemento:　Horse

2.Utilice los métodos poll(), pollFirst() y pollLast() para eliminar elementos

• poll() - Devuelve y elimina el primer elemento de la cola de dos extremos ArrayDeque

• pollFirst() - Devuelve y elimina el primer elemento de la cola de dos extremos ArrayDeque (equivalente a poll())

• pollLast() - Devuelve y elimina el último elemento de la cola de dos extremos ArrayDeque

Nota:Si la cola de dos extremos ArrayDeque está vacía, si no se encuentra el elemento, poll(), pollFirst() y pollLast() devuelven null.

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("Vaca");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque:　"　+　animals);
　　　　　　　　//Utilice poll()
　　　　　　　　String element = animals.poll();
　　　　　　　　System.out.println("Eliminar Elemento: ")　+　element);
　　　　　　　　System.out.println("Nuevo ArrayDeque:　"　+　animals);
　　　　　　　　//Utilice pollFirst()
　　　　　　　　String　firstElement　=　animals.pollFirst();
　　　　　　　　System.out.println("Eliminar el primer elemento:　"　+　firstElement);
　　　　　　　　//Uso de pollLast()
　　　　　　　　String　lastElement　=　animals.pollLast();
　　　　　　　　System.out.println("Eliminar el último elemento:　"　+　lastElement);
　　　　}
}

resultado de salida

ArrayDeque:　[Dog,　Cat,　Cow,　Horse]
Eliminar Elemento:　Dog
Nuevo ArrayDeque:　[Cat,　Cow,　Horse]
Eliminar el primer elemento:　Cat
Eliminar el último elemento:　Horse

3. Eliminar elemento: usar el método clear()

Para eliminar todos los elementos del ArrayDeque bidireccional, usamos el método clear(). 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);
　　　　　　　　//Uso de clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Nuevo ArrayDeque:　"　+　animals);
　　　　}
}

resultado de salida

Cola doble: [Perro, Gato, Caballo]
Nuevo ArrayDeque:　[]

Iteración en ArrayDeque

• iterator() - Devuelve un iterador que se puede usar para recorrer el ArrayDeque bidireccional

• descendingIterator() -Devuelve un iterador que se puede usar para recorrer el ArrayDeque bidireccional en orden inverso

Para usar estos métodos, debemos importar el paquete java.util.Iterator. 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:　");
　　　　　　　　//Uso de iterator()
　　　　　　　　Iterator<String>　iterate　=　animals.iterator();
　　　　　　　　while(iterate.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　System.out.print("\nReversaArrayDeque:　");
　　　　　　　　//Usar descendingIterator()
　　　　　　　　Iterator<String> desIterate = animals.descendingIterator();
　　　　　　　　while(desIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(desIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

resultado de salida

Cola doble: [Perro, Gato, Caballo]
Cola doble inversa: [Caballo, Gato, Perro]

Otros métodos

Usar ArrayDeque como pila

Para implementar una pila en JavaLIFO (último en entrar, primero en salir)Pila, se recomienda usarClase StackSe utiliza una cola doble en lugar de la clase Stack. La ArrayDeque es más rápida que la clase Stack.

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

• push() - Agregar un elemento en la parte superior de la pila

• peek() - Retornar un elemento de la parte superior de la pila

• pop() - Retornar y eliminar el 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<>();
　　　　　　　　//Agregar el elemento a la pila
　　　　　　　　stack.push("Perro");
　　　　　　　　stack.push("Gato");
　　　　　　　　stack.push("Caballo");
　　　　　　　　System.out.println("Pila: "　+　stack);
　　　　　　　　//Acceder al elemento en la parte superior de la pila
　　　　　　　　String element = stack.peek();
　　　　　　　　System.out.println("Acceder al elemento: "　+　element);
　　　　　　　　//eliminar elemento desde la parte superior de la pila
　　　　　　　　String remElement = stack.pop();
　　　　　　　　System.out.println("eliminar elemento:　"　+　remElement);
　　　　}
}

resultado de salida

Pila:　[Horse,　Cat,　Dog]
acceder al elemento:　Horse
eliminar Elemento:　Horse

ArrayDeque y la clase LinkedList

ArrayDeque yLas LinkedList de JavaImplementa la interfaz Deque. Sin embargo, existen algunas diferencias entre ellos.

• LinkedList admite elementos vacíos, mientras que ArrayDeque no.

• Cada nodo de la lista enlazada contiene enlaces a otros nodos. Esto es la razón por la que LinkedList necesita más espacio de almacenamiento que ArrayDeque.

• Si se debe implementar una estructura de datos de cola o deque, ArrayDeque puede ser más rápido que LinkedList.