0Pricing
Java Academy · Aula

PriorityQueue para Processamento Ordenado

Use PriorityQueue com ordenação natural e comparadores personalizados em cenários de agendamento de tarefas.

PriorityQueue para Processamento Ordenado é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que é uma PriorityQueue?

Uma PriorityQueue é um min-heap por padrão: o elemento com a menor ordenação natural está sempre no início. Os elementos não são ordenados internamente — apenas é garantido que o menor esteja na frente.

import java.util.PriorityQueue;

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(30);
pq.offer(10);
pq.offer(20);

System.out.println(pq.poll()); // 10 (min)
System.out.println(pq.poll()); // 20
System.out.println(pq.poll()); // 30

Estrutura interna do heap

PriorityQueue usa um min-heap binário armazenado em um vetor. O pai no índice i é sempre ≤ aos seus filhos nos índices 2i+1 e 2i+2. Isso garante offer/poll em O(log n) e peek em O(1).

Max-heap com comparador invertido

Para criar um max-heap (maior elemento primeiro), passe Comparator.reverseOrder():

PriorityQueue<Integer> maxPQ = new PriorityQueue<>(Comparator.reverseOrder());
maxPQ.offer(10);
maxPQ.offer(50);
maxPQ.offer(30);

System.out.println(maxPQ.poll()); // 50 (max)
System.out.println(maxPQ.poll()); // 30

PriorityQueue com objetos personalizados

Use um comparador para ordenar registros ou classes personalizadas:

record Job(String name, int priority) {}

PriorityQueue<Job> queue = new PriorityQueue<>(
    Comparator.comparingInt(Job::priority) // ascending priority
);
queue.offer(new Job("Backup", 5));
queue.offer(new Job("Alert", 1));
queue.offer(new Job("Report", 3));

System.out.println(queue.poll().name()); // Alert (priority 1)

Peek versus Poll

peek() retorna o elemento inicial sem removê-lo. poll() o remove e retorna. Ambos retornam null quando a fila está vazia (ao contrário de element()/remove(), que lançam uma exceção).

PriorityQueue<String> pq = new PriorityQueue<>();
pq.offer("banana");
pq.offer("apple");

System.out.println(pq.peek()); // apple (not removed)
System.out.println(pq.peek()); // apple (still there)
System.out.println(pq.poll()); // apple (removed)
System.out.println(pq.peek()); // banana

Exemplo de agendamento de tarefas

PriorityQueue é ideal para simulações de agendamento da CPU nas quais as tarefas têm prioridades diferentes:

record Task(String name, int priority) {}

PriorityQueue<Task> scheduler = new PriorityQueue<>(
    Comparator.comparingInt(Task::priority).reversed() // highest first
);
scheduler.offer(new Task("Low", 1));
scheduler.offer(new Task("Critical", 10));
scheduler.offer(new Task("Normal", 5));

while (!scheduler.isEmpty()) {
    System.out.println("Processing: " + scheduler.poll().name());
}
// Critical, Normal, Low

K menores elementos

PriorityQueue é uma ferramenta clássica para encontrar os K menores elementos sem ordenar completamente o vetor:

int[] nums = {7, 2, 5, 1, 9, 3, 8};
int k = 3;

PriorityQueue<Integer> pq = new PriorityQueue<>();
for (int n : nums) pq.offer(n);

for (int i = 0; i < k; i++) {
    System.out.print(pq.poll() + " ");
}
// 1 2 3

K maiores elementos com um max-heap

Como alternativa, mantenha um min-heap de tamanho K durante a iteração para encontrar os K maiores elementos:

int[] nums = {7, 2, 5, 1, 9, 3, 8};
int k = 3;

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int n : nums) {
    minHeap.offer(n);
    if (minHeap.size() > k) minHeap.poll(); // remove smallest
}
// minHeap now contains the 3 largest: [7, 8, 9]
System.out.println(minHeap); // order may vary

Padrão do algoritmo de Dijkstra

O algoritmo de caminho mínimo de Dijkstra depende de um min-heap para sempre expandir primeiro o nó não visitado de menor custo:

record Entry(int node, int cost) {}

PriorityQueue<Entry> pq = new PriorityQueue<>(
    Comparator.comparingInt(Entry::cost)
);
pq.offer(new Entry(0, 0)); // start node, cost 0

while (!pq.isEmpty()) {
    Entry curr = pq.poll();
    System.out.println("Visit node " + curr.node() + " cost=" + curr.cost());
    // expand neighbors...
}

A iteração não é ordenada

Iterar sobre uma PriorityQueue com NOT não retorna os elementos na ordem de prioridade — apenas poll() faz isso. Para obter uma saída ordenada, use poll repetidamente em vez de um laço para cada elemento.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.addAll(List.of(5,3,1,4,2));

// WRONG for sorted output:
for (int n : pq) System.out.print(n+" "); // unordered!

// CORRECT:
while (!pq.isEmpty()) System.out.print(pq.poll()+" "); // 1 2 3 4 5

Resumo de desempenho

Complexidade das operações de PriorityQueue:

  • offer(e): O(log n)
  • poll(): O(log n)
  • peek(): O(1)
  • contains(e): O(n)
  • remove(e): O(n)

Não é segura para uso com várias threads — use PriorityBlockingQueue para acesso simultâneo.

Verificação rápida

O que a iteração de uma PriorityQueue com um laço para cada elemento garante sobre a ordem dos elementos?

Recapitulação: PriorityQueue

Principais conclusões:

  • PriorityQueue é um min-heap: o menor elemento é retirado primeiro
  • Use Comparator.reverseOrder() para obter um max-heap
  • offer/poll em O(log n), peek em O(1)
  • Casos de uso clássicos: K-ésimo maior/menor elemento, Dijkstra e agendamento de tarefas
  • O laço para cada elemento não fornece a ordem de prioridade — use poll()

Perguntas Frequentes

A aula “PriorityQueue para Processamento Ordenado” é grátis?

Sim — o texto completo de “PriorityQueue para Processamento Ordenado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “PriorityQueue para Processamento Ordenado”?

Use PriorityQueue com ordenação natural e comparadores personalizados em cenários de agendamento de tarefas. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “PriorityQueue para Processamento Ordenado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Estrutura Interna de LinkedList
  2. Operações de Deque: Pilha e Fila
  3. LinkedList versus ArrayList: Compromissos
  4. PriorityQueue para Processamento Ordenado
← Voltar para Java Academy