Hilfe zu Vergleich von float member-Variablen mit Komparatoren

Ich bin in der Lage, vergleichen Sie Zeichenfolgen in Ordnung, aber würde gerne wissen, wie kann ich Rang floating-point-zahlen?

getChange() gibt einen String zurück. Ich möchte in der Lage sein, zu Sortieren und absteigend Sortieren. Wie kann ich dies tun?

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;
    }
}

Bin ich immer der compile-Zeit-Fehler:

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

Abgesehen von dem NaN-Problem, Sie haben keinen garantierten return-Anweisung in Ihrem code. Realistisch Sie tun, aber der compiler kann nicht sagen, dass, weil Sie haben drei verschiedene if-Anweisungen. Kann es nicht beurteilen, diejenigen, die erst zur Laufzeit, so dass es denkt, Sie könnte tatsächlich auf den letzten if-Anweisung und es gibt keine return-Klausel.

InformationsquelleAutor Sheehan Alam | 2010-09-14

14

Lesen der javadoc von Comparator#compare() Methode.

Vergleicht zwei Argumente für Ordnung. Gibt eine negative ganze Zahl, null oder eine positive ganze Zahl als das erste argument kleiner, gleich oder größer als das zweite.

So, im Grunde:
```
float change1 = o1.getChange();
float change2 = o2.getChange();
if (change1 < change2) return -1;
if (change1 > change2) return 1;
return 0;
```
Oder, wenn Sie mögen, bedingte Operatoren:
```
return o1.getChange() < o2.getChange() ? -1 
     : o1.getChange() > o2.getChange() ? 1 
     : 0;
```
Sie müssen jedoch berücksichtigen, mit Float.NaN. Ich bin nicht sicher, wie Sie Sie haben möchten, Sie bestellt. Erste? Letzte? Gleichermaßen?

watch out für Schwimmer.NaN! Ich ' m vorausgesetzt, Ihre Daten nicht haben, NaNs, aber da NaN auf der einen Seite der Vergleich immer false zurückgeben (sogar Schwimmen.NaN==Float.NaN ist falsch!), Sie möchten einen Float.isNaN(wandel1) oder was auch immer überprüfen. ansonsten ist die Art anscheinend zufällig, wenn es NaN ' s beteiligt.
Ich bin immer der compile-Zeit-Fehler (siehe aktualisierte code in meiner Frage): Diese Methode muss die Rückkehr ein Resultat vom Typ int ChangeComparator.java
Die Kompilierungs-Fehler spricht für sich selbst. Sie müssen sicherstellen, dass Sie immer gibt einen int. Ich werde Bearbeiten Sie das Beispiel.

InformationsquelleAutor BalusC
15

Wie wäre es damit:
```
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);
    }
}
```
Beachten Sie, dass Java 1.4 eingeführt Float#compare(float, float) (und ein äquivalent in Double), das kann so ziemlich direkt:
```
public class ChangeComparator implements Comparator<Quote>
{
    public int compare(Quote o1, Quote o2) {
        return Float.compare(o1.getChange(), o2.getChange());
    }
}
```
(Nach Bearbeitung, merke ich, dass @BorislavGizdov erwähnt hat dies in seiner Antwort bereits.)

Ist auch erwähnenswert, dass Java 8 Komparator#vergleichen(...) und Komparator#comparingDouble(...) eine einfache Art und Weise der Konstruktion dieser Komparatoren direkt.
```
Comparator<Quote> changeComparator = Comparator.comparing(Quote::getChange);
```
Vergleichen mit boxed Float Werte.
```
Comparator<Quote> changeComparator = Comparator.comparingDouble(Quote::getChange);
```
Vergleichen mit float Werte gefördert werden, um double Werte.

Gegeben, dass es keine Comparator#comparingFloat(...) meine Präferenz wäre, die Nutzung comparingDouble(...) Methode, da diese nur um die primitive Art der Konvertierung, anstatt Boxen.

Dies ist die beste Antwort - delegieren Vergleich zu Float ' s compareTo.

InformationsquelleAutor msandiford
8

Können Sie Float.vergleichen(float f1, float f2):
```
  public static int compare(float f1, float f2)
```
Vergleicht die beiden angegebenen float Werte. Gibt den Wert 0 an, wenn f1 ist numerisch gleich f2; ein Wert kleiner als 0, wenn f1 ist numerisch kleiner als f2; und ein Wert größer als 0, wenn f1 ist numerisch größer als f2.
InformationsquelleAutor Borislav Gizdov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.