# float Nachkommastellen abschneiden



## halosdf (19. Oktober 2007)

Hallo alle zusammen!

Ich möchte bei einem Float alle Nachkommastellen , bis auf eine, abschneiden. Allerdings soll nicht gerundet werden und auch nicht in einen String oder sonst was umgewandelt werden. Es muss danach wieder ein Float-Wert vorhanden sein.

Beispiel:

2.3654

nach dem Abschneiden : 2.3

also wie gesagt, nicht gerundet.

Es geht dabei nämlich um eine Methode die diesen Float zurückgibt. deshalb auch keine Umwandlung in String o.Ä

Ich bin dankbar für jede Hilfe!

mfg


----------



## Anime-Otaku (19. Oktober 2007)

Mal 10, Runden, Durch 10*.* Teilen^^

Spontan fällt mir keinen eleganteren Weg ein

Achja, bei Berechnungen mit Fließkommazahlen (also dezimal) Zahlen solltest du aufpassen. Siehe dazu http://de.wikipedia.org/wiki/IEEE_754

Für genaue Operationen und mehr Auswahl an Operation sollte man BigDecimal benutzen (Bringt jedoch mehr overhead mit natürlich)


----------



## halosdf (19. Oktober 2007)

Schonmal danke !

aber...gibt es nicht von Java aus eine Methode die sowas kann? Ich hab in der API nichts gefunden. Aber so etwas simples muss es doch geben...Das eine Gleitkommazahl nur bis zu einer bestimmen Nachkommastelle ausgegeben werden soll.

mfg


----------



## Thomas Darimont (19. Oktober 2007)

Hallo,

schau mal hier:

```
/**
 * 
 */
package de.tutorials;

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;

/**
 * @author Thomas.Darimont
 */
public class RoundFloatExample {

  /**
   * @param args
   */
  public static void main(String[] args) {
    float value = 2.3654f;

    NumberFormat numberFormat = new DecimalFormat("0.0");
    numberFormat.setRoundingMode(RoundingMode.DOWN);
    System.out.println(numberFormat.format(value));
  }

}
```

Gruß Tom


----------



## Mnyut (19. Dezember 2008)

Ich habe ein Problem beim Rechnen mit Java. Eigentlich soll 9,90 raus kommen, aber es kommt fast immer  (ja, manch mal kommen tatsächlich 9,90 raus) 9,89 als Ergebnis.

Was mache ich Falsch? Ist recht viel, aber ich hab's etwas ausführlicher gemacht damit man in jedem Schritt sieht was passiert:




```
float j, m;
int n;


// intIn(): 9900          // interne Verwndung in ms, anzeigen aber in Sekunden oder auch Hz in kHz anzeigen.
// multiplier: 1
// divider: 1000

n = (multiplier * intIn() / divider);			// Zahl vor dem Komma
// Zahl vor dem Komma: 9

j = (multiplier * (float)intIn() / divider);              // Zahl in Sekunden oder kHz
// Zahl komplett: 9.9

n = (int)((j - n) * 100);     // es bleibt der Rest nach dem Komma, eventueller Rest "fällt hinten runter"
// Zahl nach dem Komma: 89

m = n;
m = m / 100; // jetzt sind es höchstens noch zwei Stellen nach dem Komma
// Zahl nach dem Komma fertig: 0.89

j = (multiplier * intIn() / divider;    //Zahl vor dem Komma
j = j + m;      // + Zahl nach dem Komma

// Zahl fertig: 9.89
```

Jetzt die Variante mit setRoundingMode, auch da das selbe:


```
j = (multiplier * (float)intIn() / divider);

// j =  9.9

NumberFormat cut = new DecimalFormat("0.00");
cut.setRoundingMode(RoundingMode.DOWN);

// Ausgabe: 9,89
```


----------



## VinoRosso (19. Dezember 2008)

java hat probleme beim rechnen (unglaublich aber wahr).

das problem sollte sich erledigen wenn du vorher alles mit 10000 oder mehr multiplizierst und am ende wieder durch 10000 teilst.


----------



## Mnyut (19. Dezember 2008)

Danke, du hast recht. Wirklich unglaublich.

habe jetzt

n = (int)((j - n) * 100);     // es bleibt der Rest nach dem Komma, eventueller Rest "fällt hinten runter"


durch

n = n * 1000000;	// Rechenfehler von Java ausgleichen
j = j * 1000000;	// Rechenfehler von Java ausgleichen

n = (int)((j - n) * 100);

n = n / 1000000;	// Rechenfehler von Java ausgleichen


ersetzt und es geht plötzlich.
Dann kann's ja jetzt an's zusammenfassen und vereinfachen gehen


----------



## zeja (19. Dezember 2008)

Es ist nicht so dass Java Probleme beim Rechnen mit Fließkommazahlen hat. Ihre müßt euch klar machen wie eine Fließkommazahl überhaupt abgelegt wird. Und zwar als einfache Binärzahl einer bestimmten Länge. Durch diese begrenzte Länge ist auch die Genauigkeit begrenzt. Der oben genannte Algorithmus beschreibt das Verfahren für die Umwandlung.

Um genaue Ergebnisse zu erhalten sollte man daher mit BigDecimal rechnen. Hier kann man die gewünschte Genauigkeit angeben.


----------

