Java PriorityQueue

En este tutorial, aprenderemos sobre la clase PriorityQueue del marco de colecciones de Java con la ayuda de ejemplos.

DataStax Luna: soporte flexible y económico para Apache Cassandra ™ de código abierto.ANUNCIOS A TRAVÉS DE CARBONO

La PriorityQueueclase proporciona la funcionalidad de la estructura de datos del montón .

Implementa la interfaz de cola .

A diferencia de las colas normales, los elementos de cola prioritarios se recuperan en orden ordenado.

Supongamos que queremos recuperar elementos en orden ascendente. En este caso, el encabezado de la cola de prioridad será el elemento más pequeño. Una vez que se recupera este elemento, el siguiente elemento más pequeño será la cabeza de la cola.

Es importante tener en cuenta que los elementos de una cola prioritaria no se pueden ordenar. Sin embargo, los elementos siempre se recuperan en orden ordenado.

---

Crear PriorityQueue

Para crear una cola prioritaria, debemos importar el java.util.PriorityQueuepaquete. Una vez que importamos el paquete, así es como podemos crear una cola prioritaria en Java.

PriorityQueue<Integer> numbers = new PriorityQueue<>();

Aquí, hemos creado una cola prioritaria sin ningún argumento. En este caso, el encabezado de la cola de prioridad es el elemento más pequeño de la cola. Y los elementos se eliminan en orden ascendente de la cola.

Sin embargo, podemos personalizar el orden de los elementos con la ayuda de la Comparatorinterfaz. Aprenderemos sobre eso más adelante en este tutorial.

---

Métodos de PriorityQueue

La PriorityQueueclase proporciona la implementación de todos los métodos presentes en la Queueinterfaz.

---

Insertar elementos en PriorityQueue

• add()- Inserta el elemento especificado en la cola. Si la cola está llena, arroja una excepción.
• offer()- Inserta el elemento especificado en la cola. Si la cola está llena, vuelve false.

Por ejemplo,

import java.util.PriorityQueue;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();

        // Using the add() method
        numbers.add(4);
        numbers.add(2);
        System.out.println("PriorityQueue: " + numbers);

        // Using the offer() method
        numbers.offer(1);
        System.out.println("Updated PriorityQueue: " + numbers);
    }
}

Salida

PriorityQueue: [2, 4]
PriorityQueue actualizado: [1, 4, 2]

Aquí, hemos creado una cola prioritaria llamada números . Hemos insertado 4 y 2 en la cola.

Aunque se inserta 4 antes que 2, el encabezado de la cola es 2. Esto se debe a que el encabezado de la cola de prioridad es el elemento más pequeño de la cola.

Luego hemos insertado 1 en la cola. La cola ahora se reorganiza para almacenar el elemento más pequeño 1 en la cabecera de la cola.

---

Elementos de PriorityQueue de acceso

Para acceder a elementos de una cola prioritaria, podemos usar el peek()método Este método devuelve el encabezado de la cola. Por ejemplo,

import java.util.PriorityQueue;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        System.out.println("PriorityQueue: " + numbers);

        // Using the peek() method
        int number = numbers.peek();
        System.out.println("Accessed Element: " + number);
    }
}

Salida

PriorityQueue: [1, 4, 2]
Elemento al que se accede: 1

---

Eliminar elementos de PriorityQueue

• remove() - elimina el elemento especificado de la cola
• poll() - regresa y elimina la cabeza de la cola

Por ejemplo,

import java.util.PriorityQueue;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        System.out.println("PriorityQueue: " + numbers);

        // Using the remove() method
        boolean result = numbers.remove(2);
        System.out.println("Is the element 2 removed? " + result);

        // Using the poll() method
        int number = numbers.poll();
        System.out.println("Removed Element Using poll(): " + number);
    }
}

Salida

PriorityQueue: [1, 4, 2]
¿Se ha eliminado el elemento 2? Cierto
Elemento eliminado utilizando poll (): 1

---

Iterando sobre una prioridad

Para iterar sobre los elementos de una cola prioritaria, podemos usar el iterator()método. Para utilizar este método, debemos importar el java.util.Iteratorpaquete. Por ejemplo,

import java.util.PriorityQueue;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        System.out.print("PriorityQueue using iterator(): ");

        //Using the iterator() method
        Iterator<Integer> iterate = numbers.iterator();
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Salida

PriorityQueue usando iterator (): 1, 4, 2,

---

Otros métodos PriorityQueue

Métodos	Descripciones
contains(element)	Busca en la cola de prioridad el elemento especificado. Si se encuentra el elemento, regresa true, si no regresa false.
size()	Devuelve la longitud de la cola de prioridad.
toArray()	Convierte una cola prioritaria en una matriz y la devuelve.

---

Comparador PriorityQueue

En todos los ejemplos anteriores, los elementos de la cola de prioridad se recuperan en el orden natural (orden ascendente). Sin embargo, podemos personalizar este pedido.

Para esto, necesitamos crear nuestra propia clase de comparación que implemente la Comparatorinterfaz. Por ejemplo,

import java.util.PriorityQueue;
import java.util.Comparator;
class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>(new CustomComparator());
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        numbers.add(3);
        System.out.print("PriorityQueue: " + numbers);
    }
}

class CustomComparator implements Comparator<Integer> {

    @Override
    public int compare(Integer number1, Integer number2) {
        int value =  number1.compareTo(number2);
        // elements are sorted in reverse order
        if (value > 0) {
            return -1;
        }
        else if (value < 0) {
            return 1;
        }
        else {
            return 0;
        }
    }
}

Salida

PriorityQueue: [4, 3, 1, 2]

En el ejemplo anterior, hemos creado una cola prioritaria que pasa la clase CustomComparator como argumento.

La clase CustomComparator implementa la Comparatorinterfaz.

Luego anulamos el compare()método. El método ahora hace que la cabeza del elemento sea el número más grande.

Para obtener más información sobre el comparador, visite Java Comparator .