AbstractQueue en Java con ejemplos

La clase AbstractQueue en Java es parte de Java Collection Framework e implementa la interfaz Collection y la clase AbstractCollection . Proporciona implementaciones esqueléticas de algunas operaciones de cola . Las implementaciones en esta clase son apropiadas cuando la implementación base no permite elementos nulos. Los métodos add, remove y element se basan en la oferta, la encuesta y el vistazo, respectivamente, pero lanzan excepciones en lugar de indicar fallas a través de devoluciones falsas o nulas. Jerarquía de clases:
 

java.lang.Object
 ↳ java.util.AbstractCollection<E>
    ↳ Class AbstractQueue<E>

Esta clase implementa interfaces Iterable<E> , Collection<E> , Queue<E> y extiende AbstractCollection

Declaración: 

clase abstracta pública AbstractQueue<E> extiende AbstractCollection<E> implementa Queue<E> 
 

E – Tipo de elemento mantenido por la clase o interfaz Collection Framework.

Constructores en Java AbstractQueue

Dado que AbstractQueue es una clase abstracta, su implementación la proporcionan sus subclases. A continuación se muestra la lista de clases que pueden proporcionar la implementación. Para crearlo, lo necesitamos desde java.util.AbstractQueue .

protected AbstractQueue() : El constructor predeterminado, pero al ser abstracto, no permite crear un objeto AbstractQueue. La implementación debe ser proporcionada por una de sus subclases como ArrayBlockingQueue , ConcurrentLinkedQueue , DelayQueue , LinkedBlockingDeque , LinkedBlockingQueue , LinkedTransferQueue , PriorityBlockingQueue , PriorityQueue , SynchronousQueue .

AbstractQueue<E> objName = new ArrayBlockingQueue<E>();

 A continuación se muestra un programa de muestra para ilustrar AbstractQueue en Java: 
 

// Java code to illustrate AbstractQueue
 
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
 
public class AbstractQueueExample {
 
    public static void main(String[] argv) throws Exception
    {
        // Creating object of AbstractQueue<Integer>
        AbstractQueue<Integer> AQ = new LinkedBlockingQueue<Integer>();
 
        // Adding elements to the Queue
        AQ.add(10);
        AQ.add(20);
        AQ.add(30);
        AQ.add(40);
        AQ.add(50);
 
        // print the queue contents to the console
        System.out.println("AbstractQueue contains: " + AQ);
    }
}

AbstractQueue contains: [10, 20, 30, 40, 50]

Operaciones básicas

1. Agregar elementos

Para agregar elementos a AbstractQueue, proporciona dos métodos. El método add(E e) inserta el elemento especificado en esta cola si es posible hacerlo inmediatamente sin violar las restricciones de capacidad. Devuelve verdadero en caso de éxito y lanza una IllegalStateException si no hay espacio disponible actualmente. El método addAll(E e) agrega todos los elementos de la colección especificada a esta cola.

// Java program to illustrate the
// adding elements to the AbstractQueue
 
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
 
public class AddingElementsExample {
 
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();
 
        // Populating AQ
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);
 
        // print AQ
        System.out.println("AbstractQueue contains : "
                           + AQ1);
 
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ2 = new LinkedBlockingQueue<Integer>();
 
        // print AQ2 initially
        System.out.println("AbstractQueue2 initially contains : " + AQ2);
 
        // adds elements of AQ1 in AQ2
        AQ2.addAll(AQ1);
 
        System.out.println( "AbstractQueue1 after addition contains : " + AQ2);
    }
}

AbstractQueue contains : [10, 20, 30, 40, 50]
AbstractQueue2 initially contains : []
AbstractQueue1 after addition contains : [10, 20, 30, 40, 50]

2. Elimina los Elementos 

Para eliminar los elementos de AbstractQueue, proporciona métodos remove() y clear().

• El método remove() regresa y elimina la cabeza de esta cola.
• El método clear() elimina todos los elementos de esta cola. La cola estará vacía después de que regrese esta llamada.

// Java program to illustrate the
// removal of elements from AbstractQueue
 
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
 
public class RemovingElementsExample {
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();
 
        // Add elements using add method
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);
 
        // print the queue contents to the console
        System.out.println("AbstractQueue1 contains : " + AQ1);
 
        // Retrieves the head
        int head = AQ1.remove();
 
        // print the head element to the console
        System.out.println("head : " + head);
 
        // print the modified queue
        System.out.println("AbstractQueue1 after removal of head : " + AQ1);
 
        // remove all the elements
        AQ1.clear();
 
        // print the modified queue
        System.out.println("AbstractQueue1 : " + AQ1);
    }
}

AbstractQueue1 contains : [10, 20, 30, 40, 50]
head : 10
AbstractQueue1 after removal of head : [20, 30, 40, 50]
AbstractQueue1 : []

3. Accediendo a los Elementos

El método element() de AbstractQueue recupera, pero no elimina, la cabeza de esta cola.

// Java program to illustrate the
// accessing element from AbstractQueue
 
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
 
public class AccessingElementExample {
 
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();
 
        // Populating AQ1 using add method
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);
 
        // print AQ to the console
        System.out.println("AbstractQueue1 contains : " + AQ1);
 
        // access the head element
        System.out.println("head : " + AQ1.element());
    }
}

AbstractQueue1 contains : [10, 20, 30, 40, 50]
head : 10

Métodos de AbstractQueue

Métodos declarados en la clase java.util.AbstractCollection

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

Métodos declarados en la interfaz java.lang.Iterable

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

Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/AbstractQueue.html