Umwandlung

[gast]

Ich hab grad gemerkt, dass ein Programm von mir mit falschen Werten rechnet und wollte der Sache auf den Grund gehen.
Es soll Eurobeträge aus einer Datei auslesen, das in Cents umwandeln und damit weiter rechnen.
Die Zeile zum einlesen lautet:

i[c]=(int)(100.0*(Float.parseFloat(f.readLine().replace(',', '.'))));

So, ein wenig modifiziert, um erkennen können, was er tut:

String zeile=f.readLine();
System.out.println(zeile);
System.out.println(zeile.replace(',', '.'));
System.out.println((Float.parseFloat(zeile.replace(',', '.'))));
System.out.println(100.0*(Float.parseFloat(zeile.replace(',', '.'))));
System.out.println((int)(100.0*(Float.parseFloat(zeile.replace(',', '.')))));
i[c]=(int)(100.0*(Float.parseFloat(zeile.replace(',', '.'))));

der Output sieht dann z.B. so aus:

• 
  6.64
  6.64
  6.64
  663.9999866485596
  663

Was zur Hölle soll die 4. Zeile?!
Und wie krieg ich da richtige Werte raus?

Ach ja, hier noch ein KSKB:

public class KSKB
{
	public static void main(String[] args)
	{
		String zeile="6.64";
		System.out.println(zeile);
		System.out.println(zeile.replace(',', '.'));
		System.out.println((Float.parseFloat(zeile.replace(',', '.'))));
		System.out.println(100.0*(Float.parseFloat(zeile.replace(',', '.'))));
		System.out.println((int)(100.0*(Float.parseFloat(zeile.replace(',', '.')))));
		int i=(int)(100.0*(Float.parseFloat(zeile.replace(',', '.'))));
	}
}

 

[SlaterB]

bei float (und double) wird mit minimalen Verlust gerechnet,
die Darstellung per Bits und Bytes kann das Dezimalsystem in vertretbaren Speicheraufwand nicht ideal abbilden

verwende Math.round() vor dem Kappen der Nachkommastellen per (int),
dann gehts

 

[gast]

ja aber....
was gibts dann da viel an Aufwand und Genauigkeit?
das sind zwei Nachkommastellen, die sowieso wegmultipliziert werden sollen...

 

[SlaterB]

ein float ist eine Zahl 1,abcde.. *2^x


6.64 = 1.66 * 4
100 = 1.5625 * 64
664 = 1.296875 * 512

die kürzeste Zahl 6.64 ist hier gar die schlimmste, 0.66 ist als Binärzahl nicht in 25 Bits darzustellen, vielleicht überhaupt nicht in endlich vielen Bits,
siehe

http://www.h-schmidt.net/FloatApplet/IEEE754de.html
(6.64 eintippen)

 

[Lennart]

Es wurde schon in einem anderen Thread geschrieben, dass Gleitkommazahlen ungeeignet für Geldbeträge sind.
Leider gibt es auch Lehrbuchautoren, die das Gegenteil suggerieren.

Was zur Hölle soll die 4. Zeile?!

Eben. Man kommt in Teufels Küche.

Grüße
Lennart

 

[Leroy42]

Leider gibt es auch Lehrbuchautoren, die das Gegenteil suggerieren.

Also ich bin zwar kein Lehrbuchautor, benutze aber seit
zwei Jahren (für gewerbliche eBay-Verkäufe) einfach --
weil ich nun mal grundsätzlich faul bin :lol: --
ausschließlich doubles für Geldberechnungen, auch
in Verbindung mit einer MySQL-Datenbank auf dem
Server, mit dem sich mein Programm verbindet.

Ich habe noch nie Probleme gehabt, double's Genauigkeit
reicht für normale Geldberechnungen vollkommen aus;
zusätzlich die Ausgaben vernünftig formatieren (System.out.printf
und Konsorten) natürlich vorausgesetzt.

Aber ich lasse mich gerne eines Besseren belehren; wobei
zum Beispiel, kann es Probleme geben?

 

[Lennart]

Hallo Leroy42!

Unter bestimmten Umständen kann die Verwendung von Gleitkommatypen funktionieren.

Probleme können auftreten:
- wenn Du mit hohen Geldbeträgen rechnest,
- wenn Du eine sehr große Anzahl von Einzelpositionen addierst,
- bei Vergleichen

Vielleicht fällt jemandem noch etwas anderes ein. Bin leider kein Mathematiker.

Aber es passt einfach nicht zusammen: Gleitkommazahl ist ungenau - Geldbetrag muss genau sein.

Empfehlung in Java: BigDecimal, eventuell Long-Integer
In Datenbanksystemen: DECIMAL

Siehe auch Geld in Java

Grüße
Lennart

 

[Lennart]

Nachtrag noch

Man kommt in Teufels Küche.

Damit habe ich folgendes gemeint:
Angenommen man hat eine Abrechnungslösung für ein Unternehmen geschrieben, bei dem in kurzer Zeit viele Datensätze anfallen.

Nach ein paar Wochen im Produktiveinsatz fallen Rechenfehler auf. Diese Situation kann sehr unangenehm sein.

Beste Grüße
Lennart