Fala pessoal, blza?
Estou com um problema, tavlez seja rapidão de vocês encontrarem minha falha.
Tenho uma classe Cliente comum. Tenho uma classe ClienteComparator que implementa Comparator.
Dentro da classe ClienteComparator, no método compare() fiz o seguinte:
[code]import java.util.Comparator;
public class ClienteComparator implements Comparator{
public int compare(Cliente cli1, Cliente cli2){
if(cli1.getPrioridade() > cli2.getPrioridade())
return cli1.getPrioridade();
else
return cli2.getPrioridade();
}
}[/code]
A minha intenção é fazer com que na outra classe, a classe Fila, que criasse um PriorityQueue, adicionasse alguns clientes e:
Quem tivesse a prioridade maior (que só pode ser 1 ou 2) fosse para o topo da fila. Mas isso não acontece.
Segue a classe Fila.
[code]import java.util.PriorityQueue;
public class Fila{
public static void main(String[] args){
PriorityQueue queue = new PriorityQueue(2,new ClienteComparator());
Cliente cli2 = new Cliente(“Joao”,1);
Cliente cli1 = new Cliente(“Thiago”,2);
queue.offer(cli2);
queue.offer(cli1);
while(queue.size() > 0){
System.out.println("Topo: "+queue.peek());
queue.poll();//Remover o elemento de topo
}
}
}[/code]
A saída mostra primeiro o João com prioridade 1 e depois o Thiago com prioridade 2. Mas a minha intenção é exatamente ao contrario.
Quem tem a prioridade 2 que vá para o topo.
O engraçado é que se eu trocar a ordem de inserção no PriorityQueue e colocar primeiro o cli1 e depois o cli2 (Thiago e João),
a saída muda. Parece que não fiz direito o método compare.
Da uma força ai pessoal !
Abraços a todos.
Ola,
Tente o seguinte (Use +1, 0 ou -1) Assim :
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
class ClienteComparator implements Comparator<Cliente> {
public int compare(Cliente cli1, Cliente cli2) {
Cliente cliente1 = (Cliente)cli1;
Cliente cliente2 = (Cliente)cli2;
if (cliente1.getPrioridade() > cliente2.getPrioridade())
return -1;
else
return +1;
}
}
public class Test3 {
public static void main(String[] args) {
PriorityQueue<Cliente> queue = new PriorityQueue<Cliente>(2,new ClienteComparator());
Cliente cli2 = new Cliente("Joao", 1);
Cliente cli1 = new Cliente("Thiago", 2);
queue.offer(cli2);
queue.offer(cli1);
while (queue.size() > 0) {
System.out.println("Topo: " + queue.peek());
queue.poll();
}
}
}
Um Bean Cliente que eu mesmo criei para o exemplo acima :
[code]
public class Cliente {
String nome;
int prioridade;
public Cliente(String nome, int prioridade) {
this.nome = nome;
this.prioridade = prioridade;
}
public int getPrioridade() {
return this.prioridade;
}
@Override
public String toString() {
return "Cliente [nome=" + nome + ", prioridade=" + prioridade + "]";
}
}[/code]
Abraco.
RESOLVIDO!.
Era isso mesmo, usar o +1 e -1. BRIGADUUU
Agora, será que tu podia me explicar o pq funciona com +1 e -1???
if (cliente1.getPrioridade() > cliente2.getPrioridade())
return -1;
else
return +1;
E outra, se a prioridade do cliente1 é maior, não deveria ser:
if (cliente1.getPrioridade() > cliente2.getPrioridade())
return +1;
else
return -1;
Da um help ai que to meio confuso…
Abraço
Ola,
Eh o seguinte…
Tanto o metodo compareTo de Comparable e compare de Comparator retornam um int , e esse int deve ser -1,0 ou +1 pois eh atraves de um desses valores que os metodos se baseiam para poder fazer a comparacao entre os elementos de uma colecao.
Um exemplo bem simples :
"Ana".compareTo("Maria") => retorna negativo no caso -1 (significa que o nome Ana vem antes do nome Maria)
"Maria".compareTo("Ana") => retorna positivo no caso +1 (significa que o nome Maria esta depois do nome Ana)
"Ana".compareTo("Ana") => retorna 0 (significa que sao iguais)
Voce pode tomar isso como base para entendimento do seu codigo.
Tomara que tenha ajudado com o exemplo bem simples ai 
Qualquer coisa posta ai.
Um Abraco.
Blza, essa parte das comparações entendi.
Agora o que me chama a atenção é o fato do if
if (cliente1.getPrioridade() > cliente2.getPrioridade())
return -1;
else
return +1;
Se o cliente1 é maior, por que dentro do if retornar o -1, se -1 é quando o número é menor???
Acho que o que eu não estou conseguindo captar é o funcionamento deste if.
Por exemplo, quando que acontece o compare()? Na hora que insiro (offer(cli1)???
Não sei se é bem isto o que eu tenho que explicar, mas… to tentando XD.
Abraço
oi thiago
é isso mesmo, quando voce faz offer (e quando faz add em algumas colecoes, como nas SortedSets, e em outras ocasioes), a api de collections do java vai de alguma forma chamar o compare do seu comparator (ou compareTo da sua entidade em questao, caso nao tenha sido definido um comparator).
Isso de retornar um numero negativo, 0 ou numero positivo foi a forma que encontraram para que voce possa devolver alguma coisa indicando se o objeto é menor, igual ou maior, no seu criterio de comparacao. As interfaces Comparable e Comparator sao velhissimas, se ja houvesse o java 5, creio que optariam por usar alguma enumeracao para tal.
Ola,
Entendo sua duvida e realmente um pouco estranho mais vou tentar explicar de outra forma:
Primeira coisa nao pense assim :
Entenda que quando da -1 quer dizer que aquele elemento vem antes na colecao, ou seja esse objeto vem antes do outro, entende?
Deixando um pouco de lado o codigo
Pense da seguinte forma : Qual a ordem natural dos numero naturais : … -5, -4 ,-3 , -2 -1, 0 ,1 ,2, 3…
(do menor negativo para o maior positivo certo) ?
Se voce diz que cliente1.getPrioridade() eh maior que ( > ) cliente2.getPrioridade(), voce diz que a prioridade do cliente 1 vem antes da prioridade do cliente 2 (olhando nos numeros acima que coloquei olhe da esquerda para direita e pense assim : -1 vem antes de +1 correto ? )
Eh assim que os metodos tomam base para comparar os elementos. Agora pq eles usam -1 ou + 1 isso foi decido na criacao da implementacao desses metodos.
Nao se preocupe com seu if , ele esta certo voce so precisa entender esse conceito que estou explicando acima.
Espero que tenha dados mais uma forca ai e eu tenha conseguido ajudar.
Qualquer coisa posta denovo que eu tento explicar mais uma vez
Um Abraco.
PROMETO que será a ultima vez que posto sobre este assunto XDDDDDD.
Vamos lá, deixa ver se entendi, do modo que eu entendi.
Quando eu adiciono um objeto na lista:
queue.offer(cli1);
A prioridade do cli1 é 2
Blza, o comparator não faz nada.
Agora, quando eu adiciono o segundo:
queue.offer(cli2);
E, a prioridade do cli2 é 1, no teste do:
if(cli1.getPrioridade() > cli2.getPrioridade()), será VERDADEIRO, ou seja, retornará -1.
Esse -1 será “retornado ao cli2”, assim, a fila coloca o objeto cli2(que está com -1) ANTES do cli1(que tem a prioridade maior)???
E assim sucessivamente com os próximos elementos que entrarem???
Abraço
Ola,
Voce estava indo bem na explicacao ate chegar nessa linha e se confundir um poquinho
Eh o contrario a fila coloca o objeto cli1 antes do cli2
Olha no seu proprio codigo abaixo :
Cliente cli2 = new Cliente("Joao",1);
Cliente cli1 = new Cliente("Thiago",2);
queue.offer(cli2);
queue.offer(cli1);
Seu cli1 tem 2 de prioridade
Seu cli2 tem 1 de prioridade
Entao oque voce disse aqui esta correto ;
Sendo cli1 com prioridade maior que cli2 ele vem ANTES na lista porque retornou -1
Quando voce usa o offer voce aciona o metodo compare.
Acho que agora a explicacao ficou legal
Bem repito qualquer coisa posta ai denovo
Abraco.
Então a lista se lê da esquerda para a direita???
Abraço
Sim ,
Exemplos :
Imagine uma lista de telefones normal
O que vem antes esta em cima certo e voce le ate chegar ao ultimo que esta em baixo
Imagine agora uma fila de banco quem vai ser atendido antes eh o primeiro da fila e o segundo depois…
Simples
Abraco.
RESOLVIDO++; XDDD
Ah muuuulek, BRIGADÂOOOOOOO
Agora saquei, era isso o que estava me perturbando, era a ordem como as coisas funcionavam.
Perfeito !!!
Vlws danieldomingues86 pela paciência e pelas explicações e vlw Paulo Silveira pela explicação do método offer()
Abraços e agora sim - [RESOLVIDO]