ArrayDeque en Java

ArrayDeque en Java proporciona una forma de aplicar una array de tamaño variable además de la implementación de la interfaz Deque. También se conoce como Array Double Ended Queue o Array Deck . Este es un tipo especial de array que crece y permite a los usuarios agregar o eliminar un elemento de ambos lados de la cola. 

Algunas características importantes de ArrayDeque son las siguientes:  

• Los arreglos deques no tienen restricciones de capacidad y crecen según sea necesario para admitir el uso.
• No son seguros para subprocesos, lo que significa que, en ausencia de sincronización externa, ArrayDeque no admite el acceso simultáneo de varios subprocesos.
• Los elementos nulos están prohibidos en ArrayDeque.
• Es probable que la clase ArrayDeque sea más rápida que Stack cuando se usa como una pila.
• Es probable que la clase ArrayDeque sea más rápida que LinkedList cuando se usa como una cola.

Interfaces implementadas por ArrayDeque:

La clase ArrayDeque implementa estas dos interfaces:

• Interfaz de cola : es una interfaz que es una estructura de datos FirstIn – FirstOut donde los elementos se agregan desde la parte posterior.
• Interfaz Deque : Es una Cola Doblemente Terminada en la que se pueden insertar los elementos de ambos lados. Es una interfaz que implementa la Queue.

ArrayDeque implementa tanto Queue como Deque. Es dinámicamente redimensionable desde ambos lados. Todas las interfaces implementadas de ArrayDeque en la jerarquía son Serializable , Cloneable , Iterable<E> , Collection<E> , Deque<E> , Queue<E>

Sintaxis: Declaración

clase pública ArrayDeque<E> 

extiende AbstractCollection<E> 

implementa Deque<E>, Clonable, Serializable

Aquí, E se refiere al elemento que puede referirse a cualquier clase, como la clase Integer o String.

Ahora que hemos terminado con la sintaxis, permítanos crear constructores definidos antes de implementarlo para comprenderlo mejor y percibir mejor el resultado.
 

• ArrayDeque(): este constructor se utiliza para crear un ArrayDeque vacío y, de forma predeterminada, tiene una capacidad inicial para contener 16 elementos.

ArrayDeque<E> dq = new ArrayDeque<E>();

• ArrayDeque(Collection<? extends E> c): este constructor se usa para crear un ArrayDeque que contiene todos los elementos iguales a los de la colección especificada.

ArrayDeque<E> dq = new ArrayDeque<E>(Collection col);

• ArrayDeque(int numofElements): este constructor se utiliza para crear un ArrayDeque vacío y tiene la capacidad de contener un número específico de elementos.

ArrayDeque<E> dq = new ArrayDeque<E>(int numofElements);

Los métodos en ArrayDeque son los siguientes:

Nota: Aquí, Elemento es el tipo de elementos almacenados por ArrayDeque. 

Métodos heredados de la clase java.util.AbstractCollection

Métodos heredados de la interfaz java.util.Collection

Métodos declarados en la interfaz java.util.Deque

Ejemplo 

// Java program to Implement ArrayDeque in Java
//
 
// Importing utility classes
import java.util.*;
 
// ArrayDequeDemo
public class GGFG {
    public static void main(String[] args)
    {
        // Creating and initializing deque
        // Declaring object of integer type
        Deque<Integer> de_que = new ArrayDeque<Integer>(10);
 
        // Operations 1
        // add() method
 
        // Adding custom elements
        // using add() method to insert
        de_que.add(10);
        de_que.add(20);
        de_que.add(30);
        de_que.add(40);
        de_que.add(50);
 
        // Iterating using for each loop
        for (Integer element : de_que) {
            // Print the corresponding element
            System.out.println("Element : " + element);
        }
 
        // Operation 2
        // clear() method
        System.out.println("Using clear() ");
 
        // Clearing all elements using clear() method
        de_que.clear();
 
        // Operations 3
        // addFirst() method
 
        // Inserting at the start
        de_que.addFirst(564);
        de_que.addFirst(291);
 
        // Operation 4
        // addLast() method
        // Inserting at end
        de_que.addLast(24);
        de_que.addLast(14);
 
        // Display message
        System.out.println(
            "Above elements are removed now");
 
        // Iterators
 
        // Display message
        System.out.println(
            "Elements of deque using Iterator :");
 
        for (Iterator itr = de_que.iterator();
             itr.hasNext();) {
            System.out.println(itr.next());
        }
 
        // descendingIterator()
        // To reverse the deque order
        System.out.println(
            "Elements of deque in reverse order :");
 
        for (Iterator dItr = de_que.descendingIterator();
             dItr.hasNext();) {
            System.out.println(dItr.next());
        }
 
        // Operation 5
        // element() method : to get Head element
        System.out.println(
            "\nHead Element using element(): "
            + de_que.element());
 
        // Operation 6
        // getFirst() method : to get Head element
        System.out.println("Head Element using getFirst(): "
                           + de_que.getFirst());
 
        // Operation 7
        // getLast() method : to get last element
        System.out.println("Last Element using getLast(): "
                           + de_que.getLast());
 
        // Operation 8
        // toArray() method :
        Object[] arr = de_que.toArray();
        System.out.println("\nArray Size : " + arr.length);
 
        System.out.print("Array elements : ");
 
        for (int i = 0; i < arr.length; i++)
            System.out.print(" " + arr[i]);
 
        // Operation 9
        // peek() method : to get head
        System.out.println("\nHead element : "
                           + de_que.peek());
 
        // Operation 10
        // poll() method : to get head
        System.out.println("Head element poll : "
                           + de_que.poll());
 
        // Operation 11
        // push() method
        de_que.push(265);
        de_que.push(984);
        de_que.push(2365);
 
        // Operation 12
        // remove() method : to get head
        System.out.println("Head element remove : "
                           + de_que.remove());
 
        System.out.println("The final array is: " + de_que);
    }
}

Element : 10
Element : 20
Element : 30
Element : 40
Element : 50
Using clear() 
Above elements are removed now
Elements of deque using Iterator :
291
564
24
14
Elements of deque in reverse order :
14
24
564
291

Head Element using element(): 291
Head Element using getFirst(): 291
Last Element using getLast(): 14

Array Size : 4
Array elements :  291 564 24 14
Head element : 291
Head element poll : 291
Head element remove : 2365
The final array is: [984, 265, 564, 24, 14]

Si hay algún retraso en la claridad en este ejemplo, entonces estamos proponiendo varias operaciones en la clase ArrayDeque. Veamos cómo realizar algunas operaciones de uso frecuente en ArrayDeque para comprender mejor las operaciones que hemos usado anteriormente para ilustrar Array Deque como un todo.

• Agregar operación
• Operación de acceso
• Eliminación de operaciones
• Iterando a través del Deque

Repasemos cada una de las operaciones implementando junto con el programa java limpio de la siguiente manera:

Operación 1: Adición de elementos

Para agregar un elemento al ArrayDeque, podemos usar los métodos add(), addFirst(), addLast(), offer(), offerFirst(), offerLast().

• agregar()
• agregarprimero()
• añadirÚltimo()
• oferta()
• ofertaprimero()
• ofertaÚltimo()

Ejemplo

// Java program to Illustrate Addition of elements
// in ArrayDeque
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
// AddingElementsToArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Initializing a deque
        // since deque is an interface
        // it is assigned the
        // ArrayDeque class
        Deque<String> dq = new ArrayDeque<String>();
 
        // add() method to insert
        dq.add("The");
        dq.addFirst("To");
        dq.addLast("Geeks");
 
        // offer() method to insert
        dq.offer("For");
        dq.offerFirst("Welcome");
        dq.offerLast("Geeks");
 
        // Printing Elements of ArrayDeque to the console
        System.out.println("ArrayDeque : " + dq);
    }
}

ArrayDeque : [Welcome, To, The, Geeks, For, Geeks]

Operación 2: Acceso a los Elementos

Después de agregar los elementos, si deseamos acceder a los elementos, podemos usar métodos incorporados como getFirst(), getLast(), etc.

• obtenerPrimero()
• obtener ultimo()
• ojeada()
• mirarPrimero()
• mirarÚltimo()

Ejemplo 

// Java program to Access Elements of ArrayDeque
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
// AccessingElementsOfArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an empty ArrayDeque
        ArrayDeque<String> de_que
            = new ArrayDeque<String>();
 
        // Using add() method to add elements into the Deque
        // Custom input elements
        de_que.add("Welcome");
        de_que.add("To");
        de_que.add("Geeks");
        de_que.add("4");
        de_que.add("Geeks");
 
        // Displaying the ArrayDeque
        System.out.println("ArrayDeque: " + de_que);
 
        // Displaying the First element
        System.out.println("The first element is: "
                           + de_que.getFirst());
 
        // Displaying the Last element
        System.out.println("The last element is: "
                           + de_que.getLast());
    }
}

ArrayDeque: [Welcome, To, Geeks, 4, Geeks]
The first element is: Welcome
The last element is: Geeks

 Operación 3. Eliminación de elementos

Para eliminar un elemento de un deque, existen varios métodos disponibles. Dado que también podemos eliminar de ambos extremos, la interfaz deque nos proporciona los métodos removeFirst() , removeLast() . Aparte de eso, esta interfaz también nos proporciona los métodos poll() , pop() , pollFirst() , pollLast() donde pop() se usa para eliminar y devolver la cabeza de la deque. Sin embargo, se usa poll() porque ofrece la misma funcionalidad que pop() y no devuelve una excepción cuando el deque está vacío. Estos conjuntos de operaciones se enumeran a continuación de la siguiente manera:

• retirar()
• removeFirst()
• eliminarÚltimo()
• encuesta()
• sondearprimero()
• última encuesta()
• estallido()

Ejemplo 

// Java program to Illustrate Removal Elements in Deque
 
// Importing all utility classes
import java.util.*;
 
// RemoveElementsOfArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Initializing a deque
        Deque<String> dq = new ArrayDeque<String>();
 
        // add() method to insert
        dq.add("One");
 
        // addFirst inserts at the front
        dq.addFirst("Two");
 
        // addLast inserts at the back
        dq.addLast("Three");
 
        // print elements to the console
        System.out.println("ArrayDeque : " + dq);
 
        // remove element as a stack from top/front
        System.out.println(dq.pop());
 
        // remove element as a queue from front
        System.out.println(dq.poll());
 
        // remove element from front
        System.out.println(dq.pollFirst());
 
        // remove element from back
        System.out.println(dq.pollLast());
    }
}

ArrayDeque : [Two, One, Three]
Two
One
Three
null

Operación 4: Iterando a través de Deque

Dado que un deque se puede iterar desde ambas direcciones, el método iterador de la interfaz deque nos proporciona dos formas de iterar. Uno de la primera y el otro de la parte de atrás. Estos conjuntos de operaciones se enumeran a continuación de la siguiente manera:

• retirar()
• iterador()
• iterador descendente()

Ejemplo

// Java program to Illustrate Iteration of Elements
// in Deque
 
// Importing all utility classes
import java.util.*;
 
// Main class
// IterateArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing an deque
        Deque<String> dq = new ArrayDeque<String>();
 
        // Adding elements at the back
        // using add() method
        dq.add("For");
 
        // Adding element at the front
        // using addFirst() method
        dq.addFirst("Geeks");
 
        // add element at the last
        // using addLast() method
        dq.addLast("Geeks");
        dq.add("is so good");
 
        // Iterate using Iterator interface
        // from the front of the queue
        for (Iterator itr = dq.iterator(); itr.hasNext();) {
 
            // Print the elements
            System.out.print(itr.next() + " ");
        }
 
        // New line
        System.out.println();
 
        // Iterate in reverse sequence in a queue
        for (Iterator itr = dq.descendingIterator();
             itr.hasNext();) {
 
            System.out.print(itr.next() + " ");
        }
    }
}

Geeks For Geeks is so good 
is so good Geeks For Geeks

 Artículos relacionados : 

• Clase Java.util.ArrayDeque en Java | Serie 1
• Clase Java.util.ArrayDeque en Java | conjunto 2
• ArrayList vs LinkedList en Java