amiguinhos to fazendo um trabalho pra faculdade, um esquema de maquina de moedas e resolvi fazer em java porem nao estou conseguindo ordenar meu array list se alguem tiver uma luz ajuda ai por favor.
private ArrayList nroMoedas;
private Moeda moeda;
private int valorEscolhido;
public MaquinaDeMoeda() {
valorEscolhido = 0;
nroMoedas = new ArrayList();
moeda = new Moeda();
}
public void ordenarMoedas(){
try{
if(!nroMoedas.isEmpty()){
System.out.println("\t contem "+nroMoedas.size()+" elementos");
Collections.sort(nroMoedas);//AQUI DA O ERRO nao executa o for
for(int i = 1; i <= nroMoedas.size(); i++){
Moeda m = (Moeda) nroMoedas.get(i);
System.out.println("\t ordenando "+i+" Moeda valor : "+m.getValor()+"..\n");
}
System.out.println("\t elementos ordenados com sucesso..");
}
}catch(Exception exp){
System.out.println("\t ERRO os elementos estao desordenados..");
exp.getMessage();
exp.printStackTrace();
}
}
esse eh o trecho do codigo que ta dando pau
Quando vc usar o sort só passando uma List, ele faz a comparação usando o método equals (de Object) com cada elemento de List. No seu caso a List contém elementos Moeda, certo?
Então vc terá que usar o método sort que passa além da List a implementação da interface Comparator.
Acho que vc colocar o código inteiro seria melhor de analisar… pois suponho que cada elemento do ArrayList seja uma Moeda.
Blz???
Oi, o sort não utiliza o sort não utiliza o equals para fazer a ordenação quando um Comparator não é informado. Ele usa, isso sim, o metodo compareTo que é definido pela interface java.lang.Comparable. Então, se vc não quiser definir um Comparator, a classe Moeda precisa implementar Comparable para fazer a ordenação sem problemas.
Vc decide agora se quer que sua classe implemente Comparable ou se define um Comparator e passa ele no sort. Eu preferiria o Comparator já que assim vc não vai ter que alterar a estrutura da sua classe. 
Até.
[quote=“cancao”]Oi, o sort não utiliza o sort não utiliza o equals para fazer a ordenação quando um Comparator não é informado. Ele usa, isso sim, o metodo compareTo que é definido pela interface java.lang.Comparable. Então, se vc não quiser definir um Comparator, a classe Moeda precisa implementar Comparable para fazer a ordenação sem problemas.
Vc decide agora se quer que sua classe implemente Comparable ou se define um Comparator e passa ele no sort. Eu preferiria o Comparator já que assim vc não vai ter que alterar a estrutura da sua classe.
Até.[/quote]
Foi mal ai…, nem tinha como ser o equals, pois retorna um boolean… viajei grandão, valeu cancao :oops:
entao amiguinhos, minha classe Moeda eh apenas um objeto com get e set de primitivas int;
public class Moeda{
private int valor;
private qtd;
public Moeda(){
this.valor = 0;
this.qtd = 0;
}
public int getValor(){
return this.moeda;
}
public void setValor(int novoValor){
this.valor = novoValor;
}
//ok existe o metodo get e set de qtd tambem apenas isso
}
entao a duvida eh. o que eu preciso fazer para utilizar o comparator?.. agora q eu me dei conta que talvez o sort se perca pois a estrutura moeda tem dois atributos talvez ele nao saiba por qual atributo ordenar? se existe uma maneira facinho de eu ajeitar isso manda ai, se nao tem vou ordenar na insercao de moedas mesmo pelo valor logico, fazendo varrendo a lista e fazendo teste se novo valor eh maior que o ultimo valor inserido.
ok abraço
Segue um exemplo…
.....
class ComparatorChaves implements Comparator {
public int compare (Object o1, Object o2) {
Moeda item1 = (Moeda) o1;
Moeda item2 = (Moeda) o2;
return /*valor negativo se o primeiro argumento for menor, 0 se for igual, e positivo se o segundo for maior;*/
}
}
Ai vc instância esta classe e passa no segundo argumento do sort… blz?
javaTeco valeu pela atenção,
porem ainda nao entendi faço essa compracao entre objetos ou entre valor de atributos do os objetos, pois quero ordenar por valor de cada moeda e nao por qtd de moeda em maquina, o segundo atributo.
cada objeto moeda eh composto por
Valor e Quantidade
por exemplo : tenho em caixa 100 moedas de 1 centavo
o objeto moeda esta com Moeda m = new Moeda( 1, 100);
onde no construtor poderia ser definido assim
public Moeda(int valor, int qtd){
this.valor = valor;
this.qtd = qtd;
}
uma nova instancia de moeda poderia ter m = new Moeda(100, 1);
o meu sort deve ordenar assim:
m posicao 1, valor 1 - qtd 100
m posicao 2, valor 100 - qtd 1;
isso porque 1 eh menor que 100 pelo campo valor e nao pelo campo quantidade. deu pra entender ou preciso escrevfer em javanes… hehe
vamos la
ArrayList nroMoedas = new ArrayList();
ComparatorChaves cc = new ComparatorChaves();
nroMoedas.add(new Moeda(100, 1));
nroMoedas.add(new Moeda(1, 100));
Collections.sort(nroMoeda, cc);
for(int i = 0; i <= nroMoeda.size(); i++){
Moeda m = (Moeda) nroMoeda.get(i);
System.out.println("\t Mostrando a cara da moeda : "+i+" com valor "+m.getValor()+" qtdade "+m.getQtdade());
}
who turn off the lights,
8) blind
Ai vai um exemplo didático para vc entender, como ficaria no seu caso… blz?
class ComparatorChaves implements Comparator {
public int compare(Object o1, Object o2) {
int valorInt1 = ( (Moeda) o1).getValor();
int valorInt2 = ( (Moeda) o2).getValor();
Integer valorInteger1 = new Integer(valorInt1);
Integer valorInteger2 = new Integer(valorInt2);
return valorInteger1.compareTo(valorInteger2);
}
}
Se você quer ver o método de ordenação mais rápido que conheço, use o quicksort. ele ordena 5.000.000 de dados em menos de 2 segundos , dependendo da máquina.
dê uma olhada neste código:
import javax.swing.*;
public class Quicksort{
public void quickSort( int conjunto[], int inicio, int fim){
int pivo=0, trab=0, i=0, j=0;
i = inicio;
j = fim;
pivo = conjunto [ (i + j) / 2 ];
do{
while (conjunto [i] < pivo) i++;
while (conjunto [j] > pivo) j–;
if (i <= j) {
trab = conjunto[i];
conjunto[i] = conjunto[j];
conjunto[j] = trab;
i = i + 1;
j = j - 1;}
} while ( i <= j );
if (inicio < j) quickSort( conjunto, inicio, j);
if (fim > i ) quickSort ( conjunto, i, fim);
}
}
[quote=“RenanCCP”]Se você quer ver o método de ordenação mais rápido que conheço, use o quicksort. ele ordena 5.000.000 de dados em menos de 2 segundos , dependendo da máquina.
dê uma olhada neste código:
import javax.swing.*;
public class Quicksort{
public void quickSort( int conjunto[], int inicio, int fim){
int pivo=0, trab=0, i=0, j=0;
i = inicio;
j = fim;
pivo = conjunto [ (i + j) / 2 ];
do{
while (conjunto [i] < pivo) i++;
while (conjunto [j] > pivo) j–;
if (i <= j) {
trab = conjunto[i];
conjunto[i] = conjunto[j];
conjunto[j] = trab;
i = i + 1;
j = j - 1;}
} while ( i <= j );
if (inicio < j) quickSort( conjunto, inicio, j);
if (fim > i ) quickSort ( conjunto, i, fim);
}
}
Não precisa implementar este algoritmo, pois o sort de Collections utiliza o quicksort para ordenar.
Valeu, Javateco, não sabia deste detalhe.
