Using Double in the compareTo method

Question

I’m having a doubt.

I have several methods of comparison, however, one of the attributes used to make the comparison is double.

Then an error occurs:

Cannot invoke compareTo(double) on the Primitive type double

I tried to convert the double to String. But he orders wrong.

He orders in order "alphabetical".

Example, sort values like this:

10, 1000, 1002, 20, 30 , 300, 40.

When it was to order like this:

10, 20 ,30 ,40 , 300, 1000 e 1002.

Here is my code:

<%! 
public static class Empreendimento implements Comparable<Empreendimento>{

// ignorar os construtores, métodos e atributos

// Para ordenar por Menor Preco
    public static void ordenaPorMenorPreco(List<Empreendimento> ArrayResultadoBusca) {
        Collections.sort(ArrayResultadoBusca, new Comparator<Empreendimento>() {
            //@Override
            public int compare(Empreendimento emp1, Empreendimento emp2) {
                return emp1.getPrecoMenor().compareTo(emp2.getPrecoMenor());
            }
        });
    }

%>

Answer 1

The autoboxing isn’t helping.

Try to do it this way:

return Double.valueOf(emp1.getPrecoMenor()).compareTo(Double.valueOf(emp2.getPrecoMenor()));

I hope it helps.

Answer 2

As you can see in the error message:

Cannot invoke compareTo(double) on the Primitive type double

You’re trying to access a method in a primitive type, but primitive types have no methods, only objects. You are working as if you are using the wrapper class object Double instead of the primitive type double.

You have three ways to solve this:

• Change both the return of the method getPrecoMenor as to the variable it returns; or
• Make the conversion at the time of comparison, as suggested in the other answer; or

• Instead of using the method compareTo() could do so:

  return emp1.getD() > emp2.getD() ? 1 : emp1.getD() < emp2.getD() ? -1 : 0 ;
  

Which is basically the same solution as @Thiago, but using two ternary conditional operators. It is less readable but more compact, leaving it up to the developer who best serves it.

The third option is given because the method compareTo(), in accordance with the documentation, returns:

the value 0 if anotherDouble is numerically Equal to this Double; a value Less than 0 if this Double is numerically Less than anotherDouble; and a value Greater than 0 if this Double is numerically Greater than anotherDouble.

In free translation, the method returns:

the value 0 if the other double is numerically equal to the object that invoked the method; a value less than 0 if the value is less than the other double; and a value greater than 0 if it is greater than the other.

Answer 3

Try it this way:

     Collections.sort(lst, new Comparator<Empreendimento>() {
        @Override
        public int compare(Empreendimento o1, Empreendimento o2) {
            if(o1.getPrecoMenor() > o2.getPrecoMenor()){
                return 1;
            }else if(o1.getPrecoMenor() < o2.getPrecoMenor()){
                return -1;
            }else 
                return 0;
        }
    });