PriorityQueue

Programação Java
#1

ae pessoal, fiqueo com duvida na linha 24 desse codigo pq o valor passado tem quer ser 10? eu coloquei 0 e deu erro nao compreendi essa sintaxe!! alguem pode me ajudar?

import java.util.*;
class Pq{
	static class PQsort implements Comparator<Integer>{
		public int compare(Integer on, Integer tow){
			return tow - on;
			//ordeno pela ordem inversa
		}
	}
	public static void main(String args[]){
		int[] ia = {1,5,3,6,7};
		PriorityQueue<Integer> pq1 = new PriorityQueue<Integer>();
		
			for(int x : ia)
				//carrega os elementos do array e ordena por ordem natural
				//observe que agora tenho um conjunto com os elementos do array
				pq1.offer(x);
				
			for(int x : ia)
				System.out.print(pq1.poll() + " ");
			System.out.println();
			
			//vou  realizar uma classificacao usador Comparator
			PQsort pqs = new PQsort();
			PriorityQueue<Integer> pq2 = new PriorityQueue<Integer>(10,pqs);
				//aqui carrego meu array para meu comparator
				for(int x : ia)
					pq2.offer(x);
				
			System.out.println("size " + pq2.size());
			System.out.println("peek " + pq2.peek());
			System.out.println("size " + pq2.size());
			//imprimo o ultimo cara que foi removido
			System.out.println("poll " + pq2.poll());
			System.out.println("size " + pq2.size());
			for(int x : ia)
				System.out.print(pq2.poll() + " ");
	}
}

valeu!!

#2

Camilo,

olha a definição do Construtor da classe PriorityQueue.


   /**
     * Creates a <tt>PriorityQueue</tt> with the specified initial capacity
     * that orders its elements according to the specified comparator.
     *
     * @param initialCapacity the initial capacity for this priority queue.
     * @param comparator the comparator used to order this priority queue.
     * If <tt>null</tt> then the order depends on the elements' natural
     * ordering.
     * @throws IllegalArgumentException if <tt>initialCapacity</tt> is less
     * than 1
     */
    public PriorityQueue(int initialCapacity, 
                         Comparator<? super E> comparator) {
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity + 1];
        this.comparator = comparator;
    }

O que vem a ser o argumento initialCapacity. É a capacidade inicial do seu objeto (fila).

#3

:? nao entendi

#4

Camilo,

o caso é o seguinte. Não se pode passar para o atributo initialCapacity o valor menor ou igual a 0, conforme havia mostrado na mensagem acima.

@throws IllegalArgumentException if initialCapacity is less * than 1

Você está querendo inicializar um objeto com tamanho (quantidade de elementos que ele pode guardar) zero. Isso não é permitido. Mude o valor para qualquer número maior ou igual a 1.

Lendo a especificação da classe PriorityQueue, nota-se que a medida que elementos vão sendo adicionados, a capacidade (quantidade de elementos que ele pode guardar) vai sendo aumentado automaticamente.
Leia abaixo e confira.

A priority queue is unbounded, but has an internal capacity governing the size of an array used to store the elements on the queue. It is always at least as large as the queue size. As elements are added to a priority queue, its capacity grows automatically. The details of the growth policy are not specified.

Espero ter ajudado. Qualquer coisa estamos aí.

#5

hum entao quer dizer que definir 10, mais caso eu adicionar alem de 10 esse valor vai ser aumentando automaticamente?

#6

Exato.

A JVM vai percebendo caso você tenha necessidade de espaços extras.

Veja o caso das coleções:

Retirado do site:
http://www.mundooo.com.br/php/modules.php?name=MOOArtigos&pa=showpage&pid=5

Melhore a performance do seu código Java

[i]
Cópia de arrays em coleções

Quando você utiliza alguma coleções, do Collection framework, os seus objetos ficam armazenados em uma array.

Uma array em java, tem tamanho fixo, e este tamanho não pode ser mudado! Então, o que acontece quando uma coleção sua atinge o tamanho máximo daquela array? A coleção cria uma nova array, de tamanho maior, e copia tudo da velha para a nova. Isto é uma operação relativamente demorada.

Você pode passar para o construtor da coleção, o tamanho inicial dela, e juntamente com isso, a incrementação do tamanho de array. Isto é, quando a sua array estoura, qual o tamanho que a nova array deve ter? Sugiro você manter esses números elevados. O HashMap tem este construtor, mas a ArrayList só tem o construtor que você passa o tamanho inicial.

Vamos ver um exemplo da ArrayList:
ArrayList al = new ArrayList();

Isto cria uma ArrayList de tamanho 10! Se você for inserir 1000 elementos nela, ela vai ficar se expandindo inúmeras vezes (a expansão do arraylista é de 150% a cada estouro de tamanho). Neste caso, a seqüência de incrementos será: 100, 150, 225, 338, 508, 761, 1141. Isto é, 6 System.arraycopy() totalmente desnecessários!

Você deve sempre utilizar o construtor que recebe o tamanho da coleção!

Para um HashMap:
HashMap hm = new HashMap(1000, 2);

Indica que eu quero um hashmap de tamanho 1000 inicialmente, e que quando estourar, passe para 2000 chaves.
Isto também é válido durante a criação de um StringBuffer. Muito cuidado! Os seus appends podem ficar muito mais rápidos se você tiver uma boa estimativa de quão grande o seu Buffer pode chegar. Arredonde para cima!
[/i]

Agora, você saberá por que é preciso definir um tamanho inicial “adequado” a cada tipo de problema.

#7