Interfaz Deque en Java con ejemplo

La interfaz Deque presente en el paquete java.util es un subtipo de la interfaz de cola . El Deque está relacionado con la cola de dos extremos que admite la adición o eliminación de elementos de cualquier extremo de la estructura de datos. Puede usarse como cola (primero en entrar, primero en salir/FIFO) o como pila (último en entrar, primero en salir/LIFO) . Deque es el acrónimo de double-ended queue .

Sintaxis: La interfaz deque se declara como:

public interface Deque extends Queue

Creación de objetos Deque Dado que Deque es una interfaz , no se pueden crear objetos del tipo deque. Siempre necesitamos una clase que amplíe esta lista para crear un objeto. Y también, después de la introducción de Generics en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en el Deque. Esta cola de tipo seguro se puede definir como:

// Obj is the type of the object to be stored in Deque Deque<Obj> deque = new ArrayDeque<Obj> ();

Ejemplo: Deque

// Java program to demonstrate the working
// of a Deque in Java
 
import java.util.*;
 
public class DequeExample {
    public static void main(String[] args)
    {
        Deque<String> deque
            = new LinkedList<String>();
 
        // We can add elements to the queue
        // in various ways
 
        // Add at the last
        deque.add("Element 1 (Tail)");
 
        // Add at the first
        deque.addFirst("Element 2 (Head)");
 
        // Add at the last
        deque.addLast("Element 3 (Tail)");
 
        // Add at the first
        deque.push("Element 4 (Head)");
 
        // Add at the last
        deque.offer("Element 5 (Tail)");
 
        // Add at the first
        deque.offerFirst("Element 6 (Head)");
 
        System.out.println(deque + "\n");
 
        // We can remove the first element
        // or the last element.
        deque.removeFirst();
        deque.removeLast();
        System.out.println("Deque after removing "
                           + "first and last: "
                           + deque);
    }
}

Operaciones utilizando la interfaz Deque y la clase ArrayDeque

Veamos cómo realizar algunas operaciones de uso frecuente en el deque usando la clase ArrayDeque. 1. Agregar elementos: para agregar un elemento en una deque, podemos usar el método add() . La diferencia entre una cola y un deque es que en deque, la adición es posible desde cualquier dirección. Por lo tanto, hay otros dos métodos disponibles llamados addFirst() y addLast() que se usan para agregar los elementos en cualquier extremo. 

// Java program to demonstrate the
// addition of elements in deque
 
import java.util.*;
public class ArrayDequeDemo {
    public static void main(String[] args)
    {
        // Initializing an deque
        Deque<String> dq
            = new ArrayDeque<String>();
 
        // add() method to insert
        dq.add("For");
        dq.addFirst("Geeks");
        dq.addLast("Geeks");
 
        System.out.println(dq);
    }
}

[Geeks, For, Geeks]

2. 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. 

// Java program to demonstrate the
// removal of elements in deque
 
import java.util.*;
public class ArrayDequeDemo {
    public static void main(String[] args)
    {
        // Initializing an deque
        Deque<String> dq
            = new ArrayDeque<String>();
 
        // add() method to insert
        dq.add("For");
        dq.addFirst("Geeks");
        dq.addLast("Geeks");
 
        System.out.println(dq);
 
        System.out.println(dq.pop());
 
        System.out.println(dq.poll());
 
        System.out.println(dq.pollFirst());
 
        System.out.println(dq.pollLast());
    }
}

[Geeks, For, Geeks]
Geeks
For
Geeks
null

3. 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. 

// Java program to demonstrate the
// iteration of elements in deque
 
import java.util.*;
public class ArrayDequeDemo {
    public static void main(String[] args)
    {
        // Initializing an deque
        Deque<String> dq
            = new ArrayDeque<String>();
 
        // add() method to insert
        dq.add("For");
        dq.addFirst("Geeks");
        dq.addLast("Geeks");
        dq.add("is so good");
 
        for (Iterator itr = dq.iterator();
             itr.hasNext();) {
            System.out.print(itr.next() + " ");
        }
 
        System.out.println();
 
        for (Iterator itr = dq.descendingIterator();
             itr.hasNext();) {
            System.out.print(itr.next() + " ");
        }
    }
}

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

La clase que implementa la interfaz Deque es ArrayDeque. ArrayDeque : la clase ArrayDeque que se implementa en el marco de la colección nos proporciona una forma de aplicar una array de tamaño variable. 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. 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. 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. Veamos cómo crear un objeto de cola usando esta clase. 

// Java program to demonstrate the
// creation of deque object using the
// ArrayDeque class in Java
 
import java.util.*;
public class ArrayDequeDemo {
    public static void main(String[] args)
    {
        // Initializing an deque
        Deque<Integer> de_que
            = new ArrayDeque<Integer>(10);
 
        // add() method to insert
        de_que.add(10);
        de_que.add(20);
        de_que.add(30);
        de_que.add(40);
        de_que.add(50);
 
        System.out.println(de_que);
 
        // clear() method
        de_que.clear();
 
        // addFirst() method to insert the
        // elements at the head
        de_que.addFirst(564);
        de_que.addFirst(291);
 
        // addLast() method to insert the
        // elements at the tail
        de_que.addLast(24);
        de_que.addLast(14);
 
        System.out.println(de_que);
    }
}

[10, 20, 30, 40, 50]
[291, 564, 24, 14]

Métodos de la interfaz Deque

Los siguientes son los métodos presentes en la interfaz deque: 

.deque-interface-java-table { borde-colapso: colapsar; ancho: 100%; } .deque-interface-java-table td { borde: 1px sólido #5fb962; alineación de texto: izquierda! importante; relleno: 8px; } .deque-interface-java-table th { borde: 1px sólido #5fb962; relleno: 8px; } .deque-interface-java-table tr>th{ color de fondo: #c6ebd9; alineación vertical: medio; } .deque-interface-java-table tr:nth-child(odd) { background-color: #ffffff; }