Problema com Comparator (RESOLVIDO)

Suponho que você tenha uma objeto Double (o que será comparado) dentro da sua classe “MeuObjeto”.
Algo assim:

public class MeuObjeto{
     public Double d;
     ...
}

Se for isso, tente fazer da seguinte maneira:

Collections.sort(anuncios, new Comparator<MeuObjeto>(){
    public int compare(MeuObjeto o1, MeuObjeto o2){
        if(o1.d.doubleValue()==0){
            return 1;
        }
        if(o2.d.doubleValue()==0){
            return -1;
        }
        return o1.d.compareTo(o2.d);
    }
});

Acho que assim deve funcionar.
Espero ter ajudado;
Valeu!

Não entendi porque o o2 recebi -1, está totalmente fora de minha lógica, estou fazendo a lógica inversa??? achei que sempre o objeto1 que era comparado primeiramente, ai sempre que ele for zero, eu seto o retorno -1, e no seu exemplo, vc coloca o -1 para o objeto 2. Qual é a ordem disso ai???

Se o objeto1 for “maior” que o objeto2 você precisa voltar um número maior que 0 para indicar isso.

Se eles forem “iguais” você retorna 0.

e se o objeto1 for “menor” que o objeto2 você precisa voltar um número menor que 0.

Se você quer ordenar eles em ordem crescente, e quer que os 0 sejam os últimos, você precisa colocar 1 quando ambos for 0…mas ainda sim não sei se vai dar certo…

[]'s

Eu discordo um pouquinho desta parte.

plano a) Na minha opinião vc deve considerar todo objeto do tipo double igual a zero como MAIOR.

plano b) Antes de ordenar retire os valores zeros da lista, aplique a ordenação e adicione os valores zeros no fundo da lista novamente.

flw

Coloquei dois “ifs” porque o zero pode vir em uma comparação tanto como primeiro parâmetro como no segundo.
Se eu deixar apenas o primeiro “if”, o metodo não comparará corretamente, por exemplo, os números -1 e 0,

Acho que não vá funcionar quando ambos forem 0 e retornar 1:

De acordo essa lógica, se tivermos dois objetos, A e B, ambos com zero,

quando compararmos A com B então A > B.
quando compararmos B com A então B > A.

A ordenação não é estável. Esse caso especial faz com que ele não seja um algoritmo de ordenação.

Mas esse algoritmo que o alpharagga quer não orderna realmente.
É uma solução que atende apenas o problema dele.
Quando ambos os objetos a serem ordenados forem zero, não faz diferença.

Valeu ai a todos, principalmente Richard e lavh, era erro de lógica, não por eu estar fazendo a lógica errada e sim porque eu estava pontuando incorretamente. conforme vcs me mostraram e entendi agora, nesse caso de crescente, ele vai lá para o final no caso o maior, que no caso retorna geralmente 1, entao, se eu quero que o zero vá lá pro final, eu retorno 1 quando o objeto comparado em questão for 0, digo, o atributo dele. obrigado a todos mesmo, já estava querendo usar a marreta. usar uma lista auxiliar para separar os valores zero, mas não foi preciso, obviamente.

segue o código final:

Collections.sort(colecao, new Comparator<Objeto>() {
	public int compare(Objeto objeto1, Objeto objeto2) {
		
		int resultado = 0;

		if(objeto1.getValor() == 0 & objeto2.getValor() != 0) {
			resultado = 1;
		}
		else if(objeto1.getValor() != 0 & objeto2.getValor() == 0) {
			resultado = -1;
		}
		else if(objeto1.getValor() > objeto2.getValor()) {
			resultado = 1;
		}
		else if(objeto1.getValor() < objeto2.getValor()) {
			resultado = -1;
		}
		else if(objeto1.getValor() == objeto2.getValor()) {
			resultado = 0;
		}
		
		return resultado;

	}
});