Galera alguém pode me explicar de maneira simples o retorno do método compareTo …
duma maneira simples o compareTo retorna valores inteiros…
para a comparação de um objecto da classe com o objecto que recebe como parametro.
se o objecto que receber como parametro for igual retorna 0; se for maior retorna >0 e se for menor retorna <0.
Tambem podes redefinir o compareTo para retornar os valores que quiseres desde que sejam eles inteiros…
basta no cabeçario da tua classe escreves.
public class xpto extends CompareTo{}e ai definis os valores que quiseres kuando o objecto do parametro é maor , menor ou igual…
Valeu cara…Simple e objetivo…
Tenho uma pergunta a respeito do código abaixo:
Esse código ele está ordenando somente por Terminal, mas acontece que dentro de cada terminal tenho as datas que precisam também estarem ordenadas por exemplo:
Essa é a maneira que ele está ordenando (Errado):
Essa é maneira correta que eu preciso ordenar:
Classe Teste
TreeSet terminais = new TreeSet();
for (Iterator iterator = lista.iterator(); iterator.hasNext();)
{
Dado dado = (Dado)iterator.next();
terminais.add(dado);
}Classe Dado
public boolean equals(Object obj)
{
Dado dado = (Dado)obj;
if ((getData()+getTerminal()).equals((dado.getData()+dado.getTerminal())))
{
return true;
}else
{
return false;
}
}
public int compareTo(Dado o)
{
int compare = (this.terminal+this.data).compareTo(o.terminal+o.data);
return compare;
}Desconsiderem o método public boolean…Ele não é utilizado na ordenação…
[code]public int compareTo(Dado o) {
int comparator
if ((this.terminal+this.data)==(o.terminal+o.data)){
compare=0; }
else if ((this.terminal+this.data)<(o.terminal+o.data))){
comparator=-1;}
else if ((this.terminal+this.data)>(o.terminal+o.data))
{comparator=1; }
return comparator;
} [/code]
nao testei este codigo mas o Compareto deve ser implementado mais ou menos assim…para devolver os valores >0; <0 ==0;
Na verdade você deve implementar a interface Comparable:
public MinhaClasseComparavel implements Comparable{}E na sua classe sobreescrever o método compareTo().
Nesse método você define quando um objeto da sua classe é maior, menor ou igual(em nível de procedência).
Por exemplo a classe String implementa a interface COmparable e define no método compareTo() quando uma String é maior/menor/igual a outra.
“Joao” vem antes de “Maria”, logo “Joao”.compareTo(“Maria”) = -1.
E na suas classes, você é quem vai definir, por exemplo, quando um objeto Usuario vem antes de outro objeto Usuário (baseado no username, no nome, na idade, etc…).
E você utiliza isso geralmente para coleções ‘sorted’, que tem uma determinada ordenacao, como num TreeSet
[quote=efcjunior]public int compareTo(Dado o)
{
int compare = (this.terminal+this.data).compareTo(o.terminal+o.data);
return compare;
}
[/quote]
Muito estranho, mas consigo ver como funciona. Só funciona por que terminal é String.
Tipo os dados que você quer ordenar são string ?
A classe string implementa a inteface comparable, então basta utilizar-se dela
se for tente:
public class SuaClasse implements Comparable<Dado> {
...
/* Ordena a lista <Dado > pela descrição */
@Override
public int compareTo(Dado other) {
return (this.terminal+this.data).compareTo(other.terminal+other.data);
}a parte de concatenação da string fica por sua conta ^^ Se quise utilizar o método concat… etc… funciona também…
Pra fazer uma segunda ordenação, use também a interface Comparator.
Não entendi Rafael.
Essa é a minha classe Dado…Qual a sugestão ?
package padrao;
import java.math.BigDecimal;
import java.util.Date;
//classe que representa o mapeamento da tabela.
public class Dado implements Comparable<Dado>{
private String terminal;
private Date data;
private Long agencia;
private Long conta;
private Integer via;
private BigDecimal valor;
public String getTerminal() {
return terminal;
}
public void setTerminal(String terminal) {
this.terminal = terminal;
}
public Date getData() {
return data;
}
public void setData(Date data) {
this.data = data;
}
public Long getAgencia() {
return agencia;
}
public void setAgencia(Long agencia) {
this.agencia = agencia;
}
public Long getConta() {
return conta;
}
public void setConta(Long conta) {
this.conta = conta;
}
public Integer getVia() {
return via;
}
public void setVia(Integer via) {
this.via = via;
}
public BigDecimal getValor() {
return valor;
}
public void setValor(BigDecimal valor) {
this.valor = valor;
}
public int compareTo(Dado o) {
int compare = (this.terminal+this.data).compareTo(o.terminal+o.data);
return compare;
}
}Aí galera, quem quiser debugar para me ajudar está aí a classe que contém o main…
package padrao.novo;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import padrao.Dado;
public class Tratador {
public List<Dado>retornoConsulta() throws ParseException{
List<Dado>listDados = new ArrayList<Dado>();
DateFormat format = new SimpleDateFormat("dd/MM/yyyy");
//1 dado:
Dado dado1 = new Dado();
dado1.setAgencia(new Long(128));
dado1.setConta(new Long(6029));
dado1.setData(format.parse("01/01/2008"));
dado1.setVia(new Integer(0));
dado1.setTerminal("1");
dado1.setValor(new BigDecimal(100));
//2 dado:
Dado dado2 = new Dado();
dado2.setAgencia(new Long(128));
dado2.setConta(new Long(6029));
dado2.setData(format.parse("01/01/2008"));
dado2.setVia(new Integer(0));
dado2.setTerminal("1");
dado2.setValor(new BigDecimal(200));
//3 dado:
Dado dado3 = new Dado();
dado3.setAgencia(new Long(128));
dado3.setConta(new Long(6029));
dado3.setData(format.parse("12/10/2006"));
dado3.setVia(new Integer(0));
dado3.setTerminal("1");
dado3.setValor(new BigDecimal(300));
//4 dado:
Dado dado4 = new Dado();
dado4.setAgencia(new Long(128));
dado4.setConta(new Long(6029));
dado4.setData(format.parse("12/10/2007"));
dado4.setVia(new Integer(0));
dado4.setTerminal("1");
dado4.setValor(new BigDecimal(500));
//5 dado:
Dado dado5 = new Dado();
dado5.setAgencia(new Long(128));
dado5.setConta(new Long(6029));
dado5.setData(format.parse("12/10/2007"));
dado5.setVia(new Integer(0));
dado5.setTerminal("2");
dado5.setValor(new BigDecimal(200));
//6 dado:
Dado dado6 = new Dado();
dado6.setAgencia(new Long(128));
dado6.setConta(new Long(6029));
dado6.setData(format.parse("12/10/2007"));
dado6.setVia(new Integer(0));
dado6.setTerminal("2");
dado6.setValor(new BigDecimal(400));
//7 dado:
Dado dado7 = new Dado();
dado7.setAgencia(new Long(128));
dado7.setConta(new Long(6029));
dado7.setData(format.parse("25/11/2007"));
dado7.setVia(new Integer(0));
dado7.setTerminal("2");
dado7.setValor(new BigDecimal(400));
//8 dado:
Dado dado8 = new Dado();
dado8.setAgencia(new Long(128));
dado8.setConta(new Long(6029));
dado8.setData(format.parse("25/11/2007"));
dado8.setVia(new Integer(0));
dado8.setTerminal("2");
dado8.setValor(new BigDecimal(400));
listDados.add(dado1);
listDados.add(dado5);
listDados.add(dado6);
listDados.add(dado7);
listDados.add(dado8);
listDados.add(dado4);
listDados.add(dado3);
listDados.add(dado2);
return listDados;
}
public static void main(String[] args) throws ParseException {
// TODO Auto-generated method stub
Collection lista = new Tratador().retornoConsulta();
float soma = 0;
//HashSet terminais = new HashSet();
TreeSet terminais = new TreeSet();
for (Iterator iterator = lista.iterator(); iterator.hasNext();) {
Dado dado = (Dado)iterator.next();
terminais.add(dado);
}
}E aí galera, responde se pelo menos existe solução, no mínimo um sim ou não por gentileza…
obrigado.
[quote=efcjunior]E aí galera, responde se pelo menos existe solução, no mínimo um sim ou não por gentileza…
obrigado.[/quote]
O que você quer fazer mesmo?
[quote=Bruno Laturner][quote=efcjunior]E aí galera, responde se pelo menos existe solução, no mínimo um sim ou não por gentileza…
obrigado.[/quote]
O que você quer fazer mesmo?[/quote]
Esta duas classes que eu coloquei acima são as que eu estou utilizando, somente… E mais em cima eu relato como eu quero exibir os dados.
Obrigado…
[code]/**
- Compara pelo Nome do Terminal e Data
*/
public int compareTo(Dado o)
{
int compare = this.terminal.compareTo(o.getTerminal());
if (compare != 0)
return compare;
return this.data.compareTo(o.getData());
}[/code]
Seria isso?
UHUUHUHUHU !!!
Cara, muito obrigado mesmo…VALEU , VALEU E VALEU !!!