Iterando através de um priorityqueue

Cara, o mecanismo mais simples de iteracao é o for-each, segue um exemplo:

PriorityQueue <String> q = new PriorityQueue <String> ();
 q.add("vinicius");
 q.add("asdf");
 q.add("2345");
 q.add("vvvvvvvvvvvvv");
 for(String s : q)
     System.out.println(s);

abracao

O iterador de um PriorityQueue realmente não retorna os itens na ordem desejada (menor elemento primeiro); conforme você mesmo disse, só dá para obter nessa ordem usando “poll”.

De fato, para obter os elementos em ordem crescente, conforme a documentação da classe java.util.PriorityQueue, faça isto aqui:

PriorityQueue <String> pq = new PriorityQueue();
... // preencher a priority queue
String[] elementos = pq.toArray();
Arrays.sort (elementos);

Vini, o que vc me passou é equivalente ao iterator… portanto nao retorna uma ordem determinada…

Thingol, ridiculo issu né veio … será que só tem essa forma mesmo?

obrigado pelas respostas

Olhei o fonte de java.util.PriorityQueue para poder lhe afirmar o que lhe disse.
O iterator retornado pelo java.util.PriorityQueue é um membro de uma classe interna, chamada Itr, que tem esse comportamento esquisito (mas que é o melhor possível dentro das devidas limitações).
Se olhar no fonte, vai ver que ele sugere exatamente essa forma (copiar e ordenar o array).

Isso é uma coisa que eu ainda não entendi em java e que cai na prova de certificação.
Afinal qual é o comportamento da PriorityQueue? E para que ela serve no fim das contas?

Nossa, nem cheguei a essa parte do livro mas já fiquei confuso.

Uma PriorityQueue é uma fila que fica sempre ordenada pelo valor do elemento inserido*. Você pode ter elementos com valores repetidos (nisso ela é diferente de um TreeSet, por exemplo), e você pode ou pegar o primeiro elemento (peek) ou então removê-lo (poll).
Há uma variação (PriorityBlockingQueue) que bloqueia ao tentar pegar o primeiro elemento, se a fila estiver vazia (take).

• Seria “mais ou menos” como se fosse uma fila de atendimento onde os mais novos é que fossem passados para a frente dos mais velhos.

thingol:

Uma PriorityQueue é uma fila que fica sempre ordenada pelo valor do elemento inserido*. Você pode ter elementos com valores repetidos (nisso ela é diferente de um TreeSet, por exemplo), e você pode ou pegar o primeiro elemento (peek) ou então removê-lo (poll).
Há uma variação (PriorityBlockingQueue) que bloqueia ao tentar pegar o primeiro elemento, se a fila estiver vazia (take).

• Seria “mais ou menos” como se fosse uma fila de atendimento onde os mais novos é que fossem passados para a frente dos mais velhos.

Traduzindo: Uma fila ordenada. Ou não?

É só isso. Mas ela é implementada internamente como um “heap” - veja seus livros de estruturas de dados para ver o que é isso; não é o “heap” da JVM.

Beleza. Se ela fosse chamada SortedQueue seria muito mais fácil entender o que faz.

Beleza. Se ela fosse chamada SortedQueue seria muito mais fácil entender o que faz.

SortedQueue é “como ela é implementada”. PriorityQueue é “para que ela serve”.

Usualmente você tenta descrever as coisas em termos de “para que servem” em vez do que “como são implementadas”.

Algumas coisas são nomeadas “como são implementadas” - um ArrayList é um List, implementado internamente como um Array. Outras têm uma mistura de “como se comportam” e “para que servem”. Um exemplo é a BlockingPriorityQueue - ela é uma PriorityQueue que bloqueia o chamador, se a fila estiver vazia.

Quanto a nomes ruins de classes, acho que nada bate no JDK a classe java.io.File.

Todo mundo aqui já fez (ou vai fazer) a besteira de tentar trabalhar com arquivos usando só java.io.File.

Ela deveria se chamar “FileInfo”, “FileMetaData” ou coisa parecida, como no .NET.

voce pode usar o

método isEmpty() para verificar se há itens ainda na queue…

PriorityQueue pq = new PriorityQueue();

while(!pq.isEmpty()) {
System.out.println(pq.poll());
}

abraço.

paraquedista srsrsrs

zuera … nunguentei a piada rsrs

nao ha perdao por aqui…huahau

Eu defino ela como uma “lista ordenada por prioridade” - Mas apenas uma pergunta/colocao

Ateh onde me lembro a definicao dela nao eh a de uma “Sorted Collection”, ou eh?

olá... entrando no meio da conversa =)

como ja foi dito a PriorityQueue tem um comportamento meio estranho oO'

import java.util.PriorityQueue;

public class PQ {

	public static void main(String[] args) {
		
		PriorityQueue<String> pq = new PriorityQueue<String>();
		
		pq.offer("D");
		pq.offer("A");
		pq.offer("B");
		pq.offer("C");
		
		for(String s : pq){
			System.out.println(s);
		}
	
	}	
}

A C B D

import java.util.PriorityQueue;

public class PQ {

	public static void main(String[] args) {
		
		PriorityQueue<String> pq = new PriorityQueue<String>();
		
		pq.offer("D");
		pq.offer("A");
		pq.offer("B");
		pq.offer("C");
				
	        for(int i=0 ;i < 4; i++){
			
			System.out.println(pq.poll());

		}
}

A B C D

com isso tiro a conclusão q PQ tem algum tipo de ordenação, porem parece q so conseguimos utilizando metodo poll ou peek...

segundo livro da Kathy;
Class: PriorityQueue
Ordered: Shorted
Sorted: By to do Order

enfim... e muito sinistro entender isso =(

javando:

while(pq.size() > 0){ System.out.println(pq.poll()); }

mas dessa forma ai em cima … os itens serão removidos , coisa que eu não quero XXD

Eu penso que ela armazene os elementos de maneira aleatória(para nos) e ela é sorted apenas quando se usa os métodos pool() e peek()…
a implementação destes metodos fariam a classificação… creio que seja isto.

bom ja q o amigo quer algo q possar ser classificado e tenha comportamento de fila…
pq não usar LinkedList… implementa List e Queue

package pct01;

import java.util.Collections;
import java.util.LinkedList;

public class Ll {

	public static void main(String[] args) {
		
		LinkedList<Integer> ll = new LinkedList<Integer>();
		
		ll.add(4);
		ll.add(1);
		ll.add(3);
		ll.add(2);
		
		// saida 1
		for(Integer s : ll){
			System.out.println(s);
		}

		// saida 2	
		for(int i=0 ;i < 4; i++){
			// isso remove dai num aparece nd la embaixo... rss
			// mais aqui ele se comporta como fila =)
			// first-in first-out
			//System.out.println(ll.poll());

		}
		
		Collections.sort(ll);
		
		// saida 3
		for(Integer s : ll){
			System.out.println(s);
		}
		
	}
	
}

Saida 1 = 4 3 2 1 Saida 2 = 4 3 2 1 Saida 3 = 1 2 3 4

Bem legal neh…

agora se vc realmente quer usar PriorityQueue faz assim:

package pct01;

import java.util.Comparator;
import java.util.PriorityQueue;

public class PQ {

	class order implements Comparator<Integer>{

		public int compare(Integer s1, Integer s2) {
			return s1.compareTo(s2);
		}
		
	}
	
	public static void main(String[] args) {
		
		PQ.order order = new PQ().new order();
		
		PriorityQueue<Integer> pq = new PriorityQueue<Integer>(4,order);
		
		pq.offer(4);
		pq.offer(1);
		pq.offer(3);
		pq.offer(2);
		
		// saida 1
		for(Integer s : pq){
			System.out.println(s);
		}
			
		
	}
	
}

acho q e isso…

enfim esse negocio e F!@$ mesmo…

fui