Java PriorityQueue

Neste tutorial, aprenderemos sobre a classe PriorityQueue do framework de coleções Java com a ajuda de exemplos.

O PriorityQueue classe fornece a funcionalidade da estrutura de dados heap.

Ele implementa a interface Queue.

Ao contrário das filas normais, os elementos da fila de prioridade são recuperados em ordem de classificação.

Suponha que queremos recuperar elementos em ordem crescente. Nesse caso, o chefe da fila de prioridade será o menor elemento. Depois que esse elemento for recuperado, o próximo menor elemento será o chefe da fila.

É importante observar que os elementos de uma fila de prioridade não podem ser classificados. No entanto, os elementos são sempre recuperados em ordem de classificação.

Criando fila de prioridade

Para criar uma fila de prioridade, devemos importar o java.util.PriorityQueue pacote. Depois de importar o pacote, veja como podemos criar uma fila de prioridade em Java.

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

Aqui, criamos uma fila de prioridade sem argumentos. Nesse caso, o chefe da fila de prioridade é o menor elemento da fila. E os elementos são removidos em ordem crescente da fila.

No entanto, podemos personalizar a ordenação dos elementos com a ajuda do Comparator interface. Vamos aprender sobre isso mais tarde neste tutorial.

Métodos de PriorityQueue

O PriorityQueue classe fornece a implementação de todos os métodos presentes no Queue interface.

Inserir elementos no PriorityQueue

add() - Insere o elemento especificado na fila. Se a fila estiver cheia, ela lançará uma exceção.
offer() - Insere o elemento especificado na fila. Se a fila estiver cheia, ela retornará false .

Por exemplo,

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);
    }
}

Saída

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

Aqui, criamos uma fila de prioridade chamada numbers . Inserimos 4 e 2 na fila.

Embora 4 seja inserido antes de 2, o cabeçalho da fila é 2. Isso ocorre porque o cabeçalho da fila prioritária é o menor elemento da fila.

Em seguida, inserimos 1 na fila. A fila agora é reorganizada para armazenar o menor elemento 1 no início da fila.

Access PriorityQueue Elements

Para acessar elementos de uma fila de prioridade, podemos usar o peek() método. Este método retorna o início da fila. Por exemplo,

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);
    }
}

Saída

PriorityQueue: [1, 4, 2]
Accessed Element: 1

Remover elementos PriorityQueue

remove() - remove o elemento especificado da fila
poll() - retorna e remove a cabeça da fila

Por exemplo,

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);
    }
}

Saída

PriorityQueue: [1, 4, 2]
Is the element 2 removed? true
Removed Element Using poll(): 1

Iterando em uma PriorityQueue

Para iterar sobre os elementos de uma fila de prioridade, podemos usar o iterator() método. Para usar este método, devemos importar o java.util.Iterator pacote. Por exemplo,

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(", ");
        }
    }
}

Saída

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

Outros métodos de fila de prioridade

Métodos	Descrições
`contains(element)`	Pesquisa a fila de prioridade para o elemento especificado. Se o elemento for encontrado, ele retornará `true` , caso contrário, retornará `false` .
`size()`	Retorna o comprimento da fila de prioridade.
`toArray()`	Converte uma fila de prioridade em uma matriz e a retorna.

Comparador PriorityQueue

Em todos os exemplos acima, os elementos da fila de prioridade são recuperados na ordem natural (ordem crescente). No entanto, podemos personalizar esta ordenação.

Para isso, precisamos criar nossa própria classe comparadora que implemente o Comparator interface. Por exemplo,

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;
        }
    }
}

Saída

PriorityQueue: [4, 3, 1, 2]

No exemplo acima, criamos uma fila de prioridade passando CustomComparator classe como argumento.

O Comparador Personalizado classe implementa o Comparator interface.

Em seguida, substituímos o compare() método. O método agora faz com que a cabeça do elemento seja o maior número.

Para saber mais sobre o comparador, visite Java Comparator.

Interface de fila Java Interface Java Deque

Java