1. Einleitung
Im echten Leben müssen wir selten „lange Rattenschwänze“ nach dem Komma sehen. Wenn Sie zum Beispiel den Preis einer Ware, das Gehalt, den Notendurchschnitt oder die Zimmerfläche berechnen, reichen Ihnen in der Regel ein paar Nachkommastellen – und nicht 15.
Zum Beispiel das Ergebnis einer Division:
double x = 10.0 / 3.0;
System.out.println(x); // 3.3333333333333335
Ein Nutzer könnte bei einem solchen Ergebnis erschrecken und denken, das Programm sei verrückt geworden. Daher müssen Zahlen oft gerundet werden – auf die nächste ganze Zahl, auf zwei Nachkommastellen usw.
In Java gibt es dafür mehrere praktische Werkzeuge.
2. Methode Math.round(): Rundung auf die nächste ganze Zahl
Der einfachste Weg, eine Zahl zu runden, ist die Methode Math.round(). Sie nimmt eine Gleitkommazahl entgegen (entweder float oder double) und gibt die nächstliegende ganze Zahl zurück.
Wie Math.round funktioniert
- Ist der Nachkommateil kleiner als 0.5 – wird abgerundet.
- Ist der Nachkommateil 0.5 oder größer – wird aufgerundet.
Beispiele:
System.out.println(Math.round(2.3)); // 2
System.out.println(Math.round(2.7)); // 3
System.out.println(Math.round(2.5)); // 3
System.out.println(Math.round(-2.5)); // -2
Rückgabetyp
- Bei Übergabe eines float wird int zurückgegeben.
- Bei Übergabe eines double wird long zurückgegeben.
float f = 5.8f;
int roundedF = Math.round(f); // 6
double d = 5.8;
long roundedD = Math.round(d); // 6
Achtung: Das überrascht mitunter – man rundet ein double und erhält ein long! Wenn Sie ein int benötigen, müssen Sie explizit casten:
int rounded = (int) Math.round(5.6); // 6
3. Rundung auf eine gewünschte Anzahl von Nachkommastellen
Oft soll nicht auf ganze Zahlen, sondern z. B. auf zwei Nachkommastellen gerundet werden (für Geldbeträge, Prozente usw.).
In Java gibt es keine „magische“ Methode wie Math.roundTo2Digits(), aber man kann das leicht selbst erledigen.
Methode 1: mathematischer Trick mit Multiplikation und Division
- Die Zahl mit 100 multiplizieren (für zwei Stellen).
- Mit Math.round auf eine ganze Zahl runden.
- Anschließend wieder durch 100 teilen.
Beispiel:
double value = 3.14159;
double rounded = Math.round(value * 100.0) / 100.0;
System.out.println(rounded); // 3.14
So funktioniert’s:
- 3.14159 * 100 = 314.159
- Math.round(314.159) = 314
- 314 / 100.0 = 3.14
4. Zahlen formatieren: die Klasse DecimalFormat
Manchmal soll eine Zahl nicht nur gerundet, sondern auch „schön“ ausgegeben werden – mit einer bestimmten Anzahl Nachkommastellen, führenden Nullen, Tausendertrennzeichen usw. Dafür gibt es in Java die Klasse DecimalFormat aus dem Paket java.text.
Wie DecimalFormat funktioniert
- Ein Objekt mit dem gewünschten Muster erzeugen.
- Seine Methode format(...) aufrufen.
import java.text.DecimalFormat;
double value = 3.14159;
DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(value)); // 3.14
Aufbau des Musters
- "0.00" – immer zwei Nachkommastellen (auch wenn die Zahl ganzzahlig ist).
- "0.###" – bis zu drei Nachkommastellen, überflüssige Nullen werden nicht ausgegeben.
- "#,##0.00" – fügt Tausendertrennzeichen hinzu (z. B. "1,234.56").
Beispiele verschiedener Muster:
| Muster | Zahl | Ergebnis |
|---|---|---|
|
2 | 2.00 |
|
2.5 | 2.50 |
|
2.567 | 2.57 |
|
2.567 | 2.567 |
|
2.5 | 2.5 |
|
12345.678 | 12,345.68 |
Beispiel mit Tausendertrennzeichen
DecimalFormat df = new DecimalFormat("#,##0.00");
System.out.println(df.format(1234567.89)); // 1,234,567.89
Beispiel: Ausgabe ohne überflüssige Nullen
DecimalFormat df = new DecimalFormat("0.##");
System.out.println(df.format(3.1)); // 3.1
System.out.println(df.format(3.141)); // 3.14
System.out.println(df.format(3.145)); // 3.15
5. Formatierung mit String.format
Für einfache Fälle ist String.format praktisch – eine eingebaute Möglichkeit, Strings zu formatieren, ähnlich wie printf in anderen Sprachen.
double value = 3.14159;
System.out.println(String.format("%.2f", value)); // 3.14
Hier bedeutet "%.2f": „Zahl mit zwei Nachkommastellen ausgeben“.
Ansätze im Vergleich:
- DecimalFormat – mächtiger, unterstützt Muster und Lokalisierung, praktisch für Tausendertrennzeichen.
- String.format – einfacher, wenn nur die Anzahl der Nachkommastellen festgelegt werden soll.
6. Besonderheiten der Rundung: Math.floor, Math.ceil, Math.rint
- Math.floor(x) – rundet ab (nach unten), auch bei negativen Zahlen.
- Math.ceil(x) – rundet auf (nach oben).
- Math.rint(x) – rundet auf die nächste ganze Zahl, gibt aber double zurück.
Beispiele:
System.out.println(Math.floor(2.7)); // 2.0
System.out.println(Math.ceil(2.1)); // 3.0
System.out.println(Math.rint(2.5)); // 2.0 (ja, kein Tippfehler!)
System.out.println(Math.rint(3.5)); // 4.0
Achtung: Math.rint rundet mitunter „zur nächstgelegenen geraden Zahl“ – diese Regel (sog. banker's rounding) hilft, die Aufsummierung von Fehlern bei vielen Berechnungen zu verringern.
7. Nützliche Feinheiten
Visualisierung: Rundungstabelle
| Zahl | Math.round | Math.floor | Math.ceil | Math.rint |
|---|---|---|---|---|
| 2.3 | 2 | 2.0 | 3.0 | 2.0 |
| 2.5 | 3 | 2.0 | 3.0 | 2.0 |
| 3.5 | 4 | 3.0 | 4.0 | 4.0 |
| -2.3 | -2 | -3.0 | -2.0 | -2.0 |
| -2.5 | -2 | -3.0 | -2.0 | -2.0 |
Rundung ist nicht Formatierung!
Es ist sehr wichtig, den Unterschied zwischen Rundung und Formatierung zu verstehen.
- Rundung – Änderung des Zahlenwerts (z. B. 2.718 → 2.72).
- Formatierung – Änderung der Darstellung bei der Ausgabe (z. B. 2.718 → "2.72" auf dem Bildschirm, im Speicher bleibt aber 2.718).
double x = 2.718;
System.out.println(String.format("%.2f", x)); // 2.72
System.out.println(x); // 2.718
Wenn Sie die gerundete Zahl in weiteren Berechnungen verwenden möchten – runden Sie mathematisch! Wenn es nur um die Ausgabe geht – formatieren Sie.
8. Typische Fehler beim Runden und Formatieren von Zahlen
Fehler Nr. 1: Nur für die Ausgabe gerundet, danach aber mit der „langen“ Zahl weitergerechnet.
Ein sehr häufiger Fall: einen schön formatierten Wert auf dem Bildschirm ausgeben und dann mit der ursprünglichen „langen“ Zahl weiterrechnen. Für Geldbeträge, Punkte und Ergebnisse gilt: zuerst runden (z. B. mit Math.round oder dem Multiplikations/Divisions-Trick), dann speichern/weitergeben.
Fehler Nr. 2: Erwartung, dass Math.round(x) ein double mit zwei Nachkommastellen zurückgibt.
Math.round() rundet immer auf die nächste ganze Zahl: Für float wird int zurückgegeben, für double – long. Für zwei Stellen verwenden Sie Multiplikation/Division oder Formatierung.
Fehler Nr. 3: DecimalFormat für Berechnungen verwenden.
DecimalFormat.format() liefert einen String. Den kann man in der Arithmetik nicht verwenden: Entweder gibt es einen Kompilierfehler oder eine NumberFormatException beim Zurückparsen.
Fehler Nr. 4: Falsches Muster für DecimalFormat.
Das Muster muss zu den Erwartungen passen: "0.00" zeigt immer zwei Stellen ("2.00"), während "0.##" überflüssige Nullen entfernt ("2", "2.1", "2.12").
Fehler Nr. 5: Präzisionsverlust bei Division durch 100.
Wenn Sie int durch int teilen, ist das Ergebnis ebenfalls int!
int a = 5;
System.out.println(a / 2); // 2, nicht 2.5!
Damit die Division „gebrochen“ ist, muss mindestens einer der Operanden double sein:
int a = 5;
System.out.println(a / 2.0); // 2.5
GO TO FULL VERSION