Aiuto per confrontare le variabili membro float usando Comparators

Question

Sono in grado di confrontare le stringhe, ma vorrei sapere come posso classificare i numeri in virgola mobile?

getChange() restituisce una stringa. Voglio essere in grado di ordinare decrescente. Come posso fare questo?

UPDATE:

package org.stocktwits.helper; 

import java.util.Comparator; 

import org.stocktwits.model.Quote; 

public class ChangeComparator implements Comparator<Quote> 
{ 
    public int compare(Quote o1, Quote o2) { 
     float change1 = Float.valueOf(o1.getChange()); 
     float change2 = Float.valueOf(o2.getChange()); 

     if (change1 < change2) return -1; 
     if (change1 == change2) return 0; // Fails on NaN however, not sure what you want 
     if (change2 > change2) return 1; 
    } 
} 

sto ottenendo l'errore di compilazione:

This method must return a result of type int ChangeComparator.java 

Answer 1

Leggi javadoc di Comparator#compare() metodo.

Compares its two arguments for order. Returns a negative integer, zero or a positive integer as the first argument is less than, equal to or greater than the second.

Quindi, fondamentalmente :

float change1 = o1.getChange(); 
float change2 = o2.getChange(); 
if (change1 < change2) return -1; 
if (change1 > change2) return 1; 
return 0; 

O se gradite operatori condizionali:

return o1.getChange() < o2.getChange() ? -1 
    : o1.getChange() > o2.getChange() ? 1 
    : 0; 

È tuttavia necessario tenere conto con Float.NaN. Non sono sicuro di come vorresti averli ordinati. Primo? Ultimo? Allo stesso modo?

Answer 2

ne dite di questo:

public class ChangeComparator implements Comparator<Quote> 
{ 
    public int compare(Quote o1, Quote o2) { 
     Float change1 = Float.valueOf(o1.getChange()); 
     Float change2 = Float.valueOf(o2.getChange()); 
     return change1.compareTo(change2); 
    } 
} 

Nota che Java 1.4 ha introdotto Float#compare(float, float) (e un equivalente in Double), che può essere più o meno direttamente utilizzato:

public class ChangeComparator implements Comparator<Quote> 
{ 
    public int compare(Quote o1, Quote o2) { 
     return Float.compare(o1.getChange(), o2.getChange()); 
    } 
} 

(Dopo la modifica, ho notato che @BorislavGizdov ha già menzionato questo nella sua risposta.)

---

Vale anche la pena notare che Java 8 Comparator#comparing(...) e Comparator#comparingDouble(...) forniscono un modo diretto per costruire questi comparatori direttamente.

Comparator<Quote> changeComparator = Comparator.comparing(Quote::getChange); 

confronterà con boxed Float valori.

Comparator<Quote> changeComparator = Comparator.comparingDouble(Quote::getChange); 

confronterà con float valori promossi a double valori.

Dato che non c'è Comparator#comparingFloat(...), la mia preferenza sarebbe quella di utilizzare il metodo comparingDouble(...), in quanto ciò riguarda solo la conversione del tipo primitivo, piuttosto che il pugilato.

Answer 3

È possibile utilizzare Float.compare(float f1, float f2):

public static int compare(float f1, float f2) 

Compares the two specified float values. Returns the value 0 if f1 is numerically equal to f2; a value less than 0 if f1 is numerically less than f2; and a value greater than 0 if f1 is numerically greater than f2.