Iterando através de um priorityqueue

Programação Java
#1

Oi … XD

eu tava tentando iterar em um priorityQueue, mas o único jeito que eu encontrei de iterar foi usando o poll e verificando se a quantidade de itens não era zero:

[code] while(pq.size() > 0){

		System.out.println(pq.poll());
		
		
	}[/code]

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

eu tentei usar o peek()

[code] while(pq.size() > 0){

		System.out.println(pq.peek());
		
		
	}[/code]

mas ele roda o while infinitamente, retornando o mesmo elemento loucamente rs

tentei usar o iterator, mas ele não retorna um conjunto ordenado, vem em uma ordem nada a ver.

idéias?

valew

#2

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

#3

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 &lt;String&gt; pq = new PriorityQueue();
... // preencher a priority queue
String[] elementos = pq.toArray();
Arrays.sort (elementos);
#4

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

#5

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).

#6

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?

#7

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

#8

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.
#9

[quote=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. [/quote]

Traduzindo: Uma fila ordenada. Ou não?

#10

É 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.

#11

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

#12

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

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.

#13

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.

#14

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.

#15

paraquedista srsrsrs

zuera … nunguentei a piada rsrs

#16

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?

#17

olá… entrando no meio da conversa =)

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

agora vamos analizar este cod / saida:

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

saida:

Muito loko… não tem logica nehuma…

agora vamos tentar assim

[code]
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());

	}

}[/code]
saida: A B C D
ordenado!!! Oo’

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 =(

#18

[quote=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
[/quote]
Já que não quer que sejam removidos, será que o que você precisa realmente é de uma fila?
Acho que esse negócio de “pegou-removeu” faz parte da natureza das Queues, pra isso elas servem… Quem sabe um Set ordenado não seja a melhor opção ?

#19

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.

#20

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