Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Java

Java PriorityQueue

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


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


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.

Java

  1. Operadores Java
  2. Comentários Java
  3. Java para cada loop
  4. Strings Java
  5. Interface Java
  6. Classe anônima Java
  7. Java try-with-resources
  8. Anotações Java
  9. Asserções Java
  10. Vetor Java