PriorityQueue Java

In questa guida, impareremo la classe PriorityQueue del framework delle collezioni Java tramite esempi.

La classe PriorityQueue fornisce le funzionalità della struttura dati heap.

ImplementaInterfaccia Queue.

Creare PriorityQueue

Per creare una coda di priorità, dobbiamo importare il pacchetto java.util.PriorityQueue. Dopo aver importato il pacchetto, possiamo creare una coda di priorità in Java utilizzando il seguente metodo.

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

Qui, abbiamo creato una coda di priorità senza parametri. In questo caso, la testa della coda di priorità è l'elemento più piccolo nella coda. Gli elementi vengono rimossi dalla coda in ordine crescente.

Ma possiamo utilizzare l'interfaccia Comparator per definire l'ordine degli elementi. Questo argomento sarà trattato nella parte posteriore di questa guida.

PriorityQueue metodo

La classe PriorityQueue fornisce tutte le implementazioni dei metodi presenti nell'interfaccia Queue.

Inserire l'elemento nella PriorityQueue

• add() - Inserire l'elemento specificato nella coda. Se la coda è piena, lancia un'eccezione.

• offer() - Inserire l'elemento specificato nella coda. Se la coda è piena, restituisce false.

Ad esempio:

import java.util.PriorityQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Creare una PriorityQueue
　　　　　　　　PriorityQueue<Integer> numbers = new PriorityQueue<>();
　　　　　　　　//Utilizzare il metodo add()
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(2);
　　　　　　　　System.out.println("PriorityQueue: " + numbers);
　　　　　　　　//Utilizzare il metodo offer()
　　　　　　　　numbers.offer(1);
　　　　　　　　System.out.println("PriorityQueue aggiornata: " + numbers);
　　　　}
}

Risultato di output

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

Qui, abbiamo creato una PriorityQueue chiamata numbers. Abbiamo inserito 4 e 2 nella coda.

Poi, inseriamo 1 nella coda. Ora la coda è stata riorganizzata per memorizzare l'elemento più piccolo 1 all'inizio della coda.

Accedere agli elementi della PriorityQueue

Per accedere agli elementi della PriorityQueue, possiamo utilizzare il metodo peek(). Questo metodo restituisce la testa della coda. Ad esempio:

import java.util.PriorityQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Creare una PriorityQueue
　　　　　　　　PriorityQueue<Integer> numbers = new PriorityQueue<>();
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(1);
　　　　　　　　System.out.println("PriorityQueue: " + numbers);
　　　　　　　　//Utilizzare il metodo peek()
　　　　　　　　int number = numbers.peek();
　　　　　　　　System.out.println("Accedere all'elemento: " + number);
　　　　}
}

Risultato di output

PriorityQueue: [1, 4, 2]
Accedere all'elemento: 1

Eliminare l'elemento dalla PriorityQueue

• remove() - Eliminare l'elemento specificato dalla coda

• poll() - Restituire ed eliminare l'inizio della coda

Ad esempio:

import java.util.PriorityQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Creare una PriorityQueue
　　　　　　　　PriorityQueue<Integer> numbers = new PriorityQueue<>();
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(1);
　　　　　　　　System.out.println("PriorityQueue: " + numbers);
　　　　　　　　//Utilizzare il metodo remove()
　　　　　　　　boolean result = numbers.remove(2);
　　　　　　　　System.out.println("L'elemento 2 è stato eliminato? " + result);
　　　　　　　　//Utilizzare il metodo poll()
　　　　　　　　int number = numbers.poll();
　　　　　　　　System.out.println("Elemento eliminato utilizzando poll(): " + number);
　　　　}
}

Risultato di output

PriorityQueue: [1, 4, 2]
L'elemento 2 è stato eliminato? true
Elemento eliminato utilizzando poll(): 1

Eseguire la scansione della PriorityQueue

Per esplorare gli elementi della coda di priorità, possiamo usare il metodo iterator(). Per utilizzare questo metodo, dobbiamo importare il pacchetto java.util.Iterator. Ad esempio,

import java.util.PriorityQueue;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建优先级队列
　　　　　　　　PriorityQueue<Integer> numbers = new PriorityQueue<>();
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(1);
　　　　　　　　System.out.print("Usa il metodo iterator() per esplorare la PriorityQueue: ");
　　　　　　　　//Usa il metodo iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Risultato di output

Usa iterator() per esplorare la PriorityQueue: 1, 4, 2,

Altri metodi della PriorityQueue

Comparatore della coda di priorità (comparator)

In tutti gli esempi precedenti, gli elementi della coda di priorità sono recuperati in ordine naturale (crescente). Ma possiamo definire noi stessi questo ordine.

Per questo, dobbiamo creare la nostra classe comparator, che implementa l'interfaccia Comparator. Ad esempio

import java.util.PriorityQueue;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建优先级队列
　　　　　　　　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);
　　　　　　　　// Gli elementi sono ordinati in ordine inverso
　　　　　　　　if (value > 0) {
　　　　　　　　　　　　return -1;
　　　　　　　　}
　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　return 1;
　　　　　　　　}
　　　　　　　　else {
　　　　　　　　　　　　return 0;
　　　　　　　　}
　　　　}
}

Risultato di output

PriorityQueue: [4, 3, 1, 2]

Nell'esempio sopra, abbiamo creato una coda di priorità, passando la classe CustomComparator come parametro.

La classe CustomComparator implementa l'interfaccia Comparator.

Poi, abbiamo sovrascritto il metodo compare(). Questo metodo ora rende la testa dell'elemento il numero maggiore.