Clase PriorityBlockingQueue en Java

PriorityBlockingQueue es una cola de bloqueo ilimitada que utiliza las mismas reglas de ordenación que la clase PriorityQueue y proporciona operaciones de recuperación de bloqueo. Dado que no tiene límites, la adición de elementos a veces puede fallar debido al agotamiento de los recursos, lo que genera OutOfMemoryError . Esta clase no permite elementos nulos. 
La clase PriorityBlockingQueue y su iterador implementan todos los métodos opcionales de las interfaces Collection e Iterator. 

No se garantiza que el Iterador provisto en el método iterator( ) y el Spliterator provisto en el método spliterator() atraviesen los elementos de PriorityBlockingQueue en un orden particular. Para un recorrido ordenado, use Arrays.sort(pq.toArray()) . Además, se puede usar el método DrainTo() para eliminar algunos o todos los elementos en orden de prioridad y colocarlos en otra colección.

Las operaciones en esta clase no garantizan el orden de los elementos con igual prioridad. Si es necesario aplicar un orden, defina clases personalizadas o comparadores que usen una clave secundaria para desempatar los valores de prioridad principal. 
Esta clase es miembro de Java Collections Framework.

La jerarquía de PriorityBlockingQueue
 

Hierarchy of PriorityBlockingQueue Class in Java

Implementa las interfaces Serializable , Iterable<E> , Collection<E> , BlockingQueue<E> , Queue<E> y extiende la clase AbstractQueue<E> .

Declaración: 

clase pública PriorityBlockingQueue<E> extiende AbstractQueue<E> implementa BlockingQueue<E>, Serializable

Aquí, E es el tipo de elementos que se encuentran en esta colección.

Constructores de PriorityBlockingQueue

Para crear una instancia de PriorityBlockingQueue, debemos importarla desde java.util.concurrent.PriorityBlockingQueue .

1. PriorityBlockingQueue()  : crea un PriorityBlockingQueue con la capacidad inicial predeterminada (11) que ordena sus elementos según su orden natural. Agregar un elemento superior a la capacidad inicial cambia la capacidad de PriorityBlockingQueue dinámicamente, ya que PriorityBlockingQueue no tiene restricciones de capacidad.

PriorityBlockingQueue<E> pbq = new PriorityBlockingQueue<E>();

Ejemplo:
 

Java

// Java program to demonstrate
// PriorityBlockingQueue() constructor
  
import java.util.concurrent.PriorityBlockingQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
  
        // create object of PriorityBlockingQueue
        // using PriorityBlockingQueue() constructor
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>();
  
        // add  numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);
        pbq.add(4);
        pbq.add(5);
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
Producción: 

PriorityBlockingQueue:[1, 2, 3, 4, 5]

 

2. PriorityBlockingQueue(Collection<? extends E> c)  : crea una PriorityBlockingQueue que contiene los elementos de la colección especificada.

PriorityBlockingQueue<E> pbq = new PriorityBlockingQueue(Colección<? extiende E> c);

Ejemplo:
 

Java

// Java program to demonstrate
// PriorityBlockingQueue(Collection c) constructor
  
import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;
  
public class GFG {
  
    public static void main(String[] args)
    {
  
        // Creating a Collection
        Vector<Integer> v = new Vector<Integer>();
        v.addElement(1);
        v.addElement(2);
        v.addElement(3);
        v.addElement(4);
        v.addElement(5);
  
        // create object of PriorityBlockingQueue
        // using PriorityBlockingQueue(Collection c)
        // constructor
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(v);
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
Producción: 

PriorityBlockingQueue:[1, 2, 3, 4, 5]

 

3. PriorityBlockingQueue(int initialCapacity)  : crea una PriorityBlockingQueue con la capacidad inicial especificada que ordena sus elementos según su orden natural.
 
Ejemplo:

Java

// Java program to demonstrate
// PriorityBlockingQueue(int initialCapacity)
// constructor
  
import java.util.concurrent.PriorityBlockingQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;
  
        // create object of PriorityBlockingQueue
        // using PriorityBlockingQueue(int initialCapacity)
        // constructor
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(capacity);
  
        // add  numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
Producción: 

PriorityBlockingQueue:[1, 2, 3]

 

4. PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparador)  : crea una PriorityBlockingQueue con la capacidad inicial especificada que ordena sus elementos de acuerdo con el comparador especificado.
 
Ejemplo:
 

Java

// Java program to demonstrate
// PriorityBlockingQueue(int initialCapacity, Comparator
// comparator) constructor
  
import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;
  
        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(
                capacity, Comparator.reverseOrder());
  
        // add  numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
Producción: 

PriorityBlockingQueue:[3, 1, 2]

 

Operaciones básicas

1. Agregar elementos

El método add(E e) de PriorityBlockingQueue inserta el elemento pasado como parámetro al método al final de esta PriorityBlockingQueue. Este método devuelve verdadero si la adición del elemento es exitosa. De lo contrario, devuelve falso.
 

Java

// Java program to demonstrate adding elements
// to the PriorityBlockingQueue
  
import java.util.concurrent.PriorityBlockingQueue;
  
public class AddingElementsExample {
  
    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;
  
        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(capacity);
  
        // add  numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
Producción: 

PriorityBlockingQueue:[1, 2, 3]

 

2. Eliminación de elementos

El método remove(Object o) de PriorityBlockingQueue se usa para eliminar un elemento de esta cola. Este método elimina una sola instancia del elemento pasado como parámetro si está presente. Devuelve verdadero si y solo si se eliminó el elemento; de lo contrario, devuelve falso. clear() se usa para eliminar todos los elementos a la vez.

Java

// Java program to demonstrate removing
// elements from the PriorityBlockingQueue
  
import java.util.concurrent.PriorityBlockingQueue;
  
public class RemovingElementsExample {
  
    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;
  
        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(capacity);
  
        // add  numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
  
        // remove all the elements
        pbq.clear();
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
Producción: 

PriorityBlockingQueue:[1, 2, 3]
PriorityBlockingQueue:[]

 

3. Accediendo a Elementos 

El método peek() de PriorityBlockingQueue devuelve el elemento al principio de PriorityBlockingQueue. Recupera el valor del encabezado de LinkedBlockingQueue pero no lo elimina. Si PriorityBlockingQueue no contiene ningún elemento, este método devuelve un valor nulo. Una cola PriorityBlockingQueue utiliza las mismas reglas de ordenación que la clase PriorityQueue.

Java

// Java Program Demonstrate accessing
// elements of PriorityBlockingQueue
  
import java.util.concurrent.PriorityBlockingQueue;
  
public class AccessingElementsExample {
    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacityOfQueue = 5;
  
        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> PrioQueue
            = new PriorityBlockingQueue<Integer>(
                capacityOfQueue);
  
        // Add elements to PriorityBlockingQueue
        PrioQueue.add(464161);
        PrioQueue.add(416165);
  
        // print PrioQueue
        System.out.println("PrioQueue: " + PrioQueue);
  
        // get head of PriorityBlockingQueue
        int head = PrioQueue.peek();
  
        // print head of PriorityBlockingQueue
        System.out.println("Head of Queue: " + head);
    }
}
Producción

PrioQueue: [416165, 464161]
Head of Queue: 416165

4. Iterando

El método iterator() de la clase PriorityBlockingQueue Devuelve un iterador sobre los elementos de esta cola. Los elementos devueltos por este método no siguen ningún orden. El iterador devuelto es débilmente coherente.

Java

// Java Program Demonstrate iterating
// over PriorityBlockingQueue
  
import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;
  
public class IteratingExample {
    public static void main(String[] args)
    {
  
        // define capacity of PriorityBlockingQueue
        int capacityOfQueue = 5;
  
        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<String> names
            = new PriorityBlockingQueue<String>(
                capacityOfQueue);
  
        // Add names of students of girls college
        names.add("Geeks");
        names.add("forGeeks");
        names.add("A");
        names.add("Computer");
        names.add("Portal");
  
        // Call iterator() method of PriorityBlockingQueue
        Iterator iteratorVals = names.iterator();
  
        // Print elements of iterator
        // created from PriorityBlockingQueue
        System.out.println("The Names are:");
  
        while (iteratorVals.hasNext()) {
            System.out.println(iteratorVals.next());
        }
    }
}
Producción

The Names are:
A
Computer
Geeks
forGeeks
Portal

5. Ejemplo de comparación

El método comparador() de PriorityBlockingQueue devuelve el comparador que se puede usar para ordenar los elementos en PriorityBlockingQueue. El método devuelve un valor nulo si la cola sigue el patrón de ordenación natural de los elementos.

Java

// Java Program Demonstrate comparator()
// method and passing Comparator to PriorityBlockingQueue
  
import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;
  
public class ComparatorExample {
    public static void main(String[] args)
        throws InterruptedException
    {
  
        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> PrioQueue
            = new PriorityBlockingQueue<Integer>(
                10, new Comparator<Integer>() {
                    public int compare(Integer a, Integer b)
                    {
                        return a - b;
                    }
                });
  
        // Add numbers to PriorityBlockingQueue
        PrioQueue.put(45815616);
        PrioQueue.put(4981561);
        PrioQueue.put(4594591);
        PrioQueue.put(9459156);
  
        // get String representation of
        // PriorityBlockingQueue
        String str = PrioQueue.toString();
  
        // Creating a comparator using comparator()
        Comparator comp = PrioQueue.comparator();
  
        // Displaying the comparator values
        System.out.println("Comparator value: " + comp);
  
        if (comp == null)
            System.out.println(
                "PriorityBlockingQueue follows natural ordering");
        else
            System.out.println(
                "PriorityBlockingQueue follows : " + comp);
    }
}
Producción

Comparator value: ComparatorExample$1@27bc2616
PriorityBlockingQueue follows : ComparatorExample$1@27bc2616

Métodos de PriorityBlockingQueue

MÉTODO

DESCRIPCIÓN

agregar​(E e) Inserta el elemento especificado en esta cola de prioridad.
clear() Elimina atómicamente todos los elementos de esta cola.
comparador() Devuelve el comparador utilizado para ordenar los elementos de esta cola, o nulo si esta cola utiliza la ordenación natural de sus elementos.
contiene​(Objeto o) Devuelve verdadero si esta cola contiene el elemento especificado.
drenajeA​(Colección<? super E> c) Elimina todos los elementos disponibles de esta cola y los agrega a la colección dada.
drenajeA​(Colección<? super E> c, int maxElements) Elimina como máximo el número dado de elementos disponibles de esta cola y los agrega a la colección dada.
forEach​(Consumidor<? super E> acción) Realiza la acción dada para cada elemento del iterable hasta que se hayan procesado todos los elementos o la acción genere una excepción.
iterador() Devuelve un iterador sobre los elementos de esta cola.
oferta​(E e) Inserta el elemento especificado en esta cola de prioridad.
oferta​(E e, tiempo de espera largo, unidad TimeUnit) Inserta el elemento especificado en esta cola de prioridad.
poner​(E e) Inserta el elemento especificado en esta cola de prioridad.
capacidad restante() Siempre devuelve Integer.MAX_VALUE porque PriorityBlockingQueue no tiene restricciones de capacidad.
eliminar​(Objeto o) Elimina una sola instancia del elemento especificado de esta cola, si está presente.
removeAll​(Colección<?> c) Elimina todos los elementos de esta colección que también están contenidos en la colección especificada (operación opcional).
removeIf​(predicado<? filtro super E>) Elimina todos los elementos de esta colección que satisfacen el predicado dado.
retenerTodo​(Colección<?> c) Retiene solo los elementos de esta colección que están contenidos en la colección especificada (operación opcional).
divisor() Devuelve un Spliterator sobre los elementos de esta cola.
aArray() Devuelve una array que contiene todos los elementos de esta cola.
a la Array​(T[] a) Devuelve una array que contiene todos los elementos de esta cola; el tipo de tiempo de ejecución de la array devuelta es el de la array especificada.

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

MÉTODO

DESCRIPCIÓN

addAll​(Colección<? extiende E> c) Agrega todos los elementos de la colección especificada a esta cola.
elemento() Recupera, pero no elimina, el encabezado de esta cola.
retirar() Recupera y elimina el encabezado de esta cola.

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

MÉTODO

DESCRIPCIÓN

contieneTodo​(Colección<?> c) Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada.
esta vacio() Devuelve verdadero si esta colección no contiene elementos.
Enstringr() Devuelve una representación de string de esta colección.

Métodos declarados en la interfaz java.util.concurrent.BlockingQueue

MÉTODO

DESCRIPCIÓN

sondeo​(tiempo de espera prolongado, unidad TimeUnit) Recupera y elimina el encabezado de esta cola, esperando hasta el tiempo de espera especificado si es necesario para que un elemento esté disponible.
tomar() Recupera y elimina el encabezado de esta cola, esperando si es necesario hasta que un elemento esté disponible.

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

MÉTODO

DESCRIPCIÓN

addAll​(Colección<? extiende E> c) Agrega todos los elementos de la colección especificada a esta colección (operación opcional).
contieneTodo​(Colección<?> c) Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada.
es igual a​(Objeto o) Compara el objeto especificado con esta colección para la igualdad.
código hash() Devuelve el valor del código hash para esta colección.
esta vacio() Devuelve verdadero si esta colección no contiene elementos.
flujoParalelo() Devuelve un Stream posiblemente paralelo con esta colección como fuente.
Talla() Devuelve el número de elementos de esta colección.
corriente() Devuelve un Stream secuencial con esta colección como fuente.
toArray​(IntFunction<T[]> generador) Devuelve una array que contiene todos los elementos de esta colección, utilizando la función de generador proporcionada para asignar la array devuelta.

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

MÉTODO

DESCRIPCIÓN

elemento() Recupera, pero no elimina, el encabezado de esta cola.
ojeada() Recupera, pero no elimina, el encabezado de esta cola o devuelve un valor nulo si esta cola está vacía.
encuesta() Recupera y elimina el encabezado de esta cola, o devuelve un valor nulo si esta cola está vacía.
retirar() Recupera y elimina el encabezado de esta cola.

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

Publicación traducida automáticamente

Artículo escrito por Code_r y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *