Skip to main content

Java Übung 24 – So kannst du Kommazahlen runden

In dieser Java Übung möchte ich mit dir Zahlen runden.

Ich bitte dich deshalb:

  • Erstelle eine Klasse „RundenUebung“.
  • Lege dann eine statische Methode rundeZahl() an.
    Diese erwartet zwei Parameter.
  • Parameter 1 ist die Kommazahl, welche gerundet werden soll.
  • Als zweiten Parameter wird eine ganze Zahl übergeben, welche die Nachkommastelle – bis auf welche letztlich gerundet werden soll – angibt.
  • In diesem Beispiel soll die Methode dann einen Double zurückgeben.
  • Die Methode wird dann in der main-Methode der Klasse „RundenUebung“ aufgerufen.
  • Übergib der Methode die Zahl 2345,335545 und die Nachkommastelle 2 und 4.
    Und lass dir das Ergebnis als Bildschirmausgabe anzeigen.


So leicht die Aufgabenstellung auch wirkt – Die Lösung zu dieser Java Übung ist etwas komplexer.

Ich bin ganz ehrlich.
Es ist für mich schwierig die Lösung mit Worten darzustellen.

Denn um es wirklich ausführlich zu machen, muss ich:

  • Erstens schrittweise vorgehen.
  • Und ich muss in den einzelnen Schritten immer mal wieder zurückspringen.

Aber genug gejammert 🙂

Lass uns die Runden-Methode einmal durchdenken und dann in der ersten Rohfassung implementieren.

Die Methode rundeZahl() bekommt eine Zahl und soll diese auf zwei Nachkommastellen runden.

Wie gehst du nun am besten vor?
Die Antwort lautet:

„Schau dir die Beispielzahl an und denke darüber nach,
wie du diese Zahl ohne Computer und ohne Java runden würdest.“

Die Zahl lautet 2345,335545.
Da du zuerst auf zwei Nachkommastellen runden sollst, kannst du:

  • Die Zahl mit 100 multiplizieren.
    Das Komma verschiebt sich dadurch um zwei Stellen nach rechts.
    Heraus kommt dann 234533,5545.
  • Danach könntest du die Nachkommastellen wegstreichen.
    Dazu müsstest du den Double-Wert in einen Integer-Wert casten.
    Heraus kommt dann 234533.
  • Und wenn du jetzt das Komma wieder nach links verschieben möchtest, musst du wieder durch 100 teilen.
    Heraus kommt dann 2345,33.

Und die Zahl 2345,335545 gerundet auf zwei Nachkommastellen lautet dann 2345,33.
Dies kommt dem Ergebnis erst einmal schon sehr nahe.

Also setzen wir das Ganze erst einmal so um.
Das wäre der Java Code dazu.


public class RundenUebung {
	
	static double rundeZahl(double zahl){
		zahl = zahl * 100; //Kommastelle verschieben = 234533,5545
		zahl = (int) zahl; //Nachkommazahlen streichen = 234533
		zahl = (double) zahl / 100; // Nachkommastellen  wieder hinzufügen = 2345,33
		return zahl;		
	}
	
	public static void main(String[] args) {
		System.out.println(rundeZahl(2345.335545));
	}

}

Das sieht schon ganz gut aus.
Wir haben noch zwei Probleme.

  1. Die Methode kann nur auf zwei Nachkommastellen runden.
    Um es flexibler zu machen, soll der Methode die Anzahl der Nachkommastellen übergeben werden.
  2. Die Methode rundet nicht richtig.
    Die Zahl 2345.335545 gerundet auf zwei Nachkommastellen wäre 2345.34 und nicht 2345.33.

Beginnen wir mit der Lösung des ersten Problems.

So kannst die Methode mit flexiblen Nachkommastellen aufrüsten.

Um das Komma nach rechts und nach links zu verschieben, haben wir Mal-100 und Geteit-Durch-100 gerechnet.

Wenn du zukünftig das Komma um drei Stellen nach rechts verschieben möchtest- müsstest du mal 1000 rechnen.

Und wenn es um drei Stellen nach links soll, rechnest du geteilt durch 1000.

Das Prinzip ist klar:
10 hoch 2 bedeutet zwei Kommastellen
10 hoch 3 bedeutet drei Kommastellen
10 hoch 25 bedeutet 25 Kommastellen.
Also lass uns die Zahl entsprechend ersetzen.

Und dafür gibt es verschiedene Möglichkeiten.
In der Java Standardklasse Math gibt es eine Methode zur Berechnung von Potenzen.
Diese nennt sich pow.

Du übergibst dieser Methode zwei Werte.
Die Basis ist in unserem Fall 10 und der Exponent wäre dann 2, 3, 25 usw.

In unserer Java Beispiel Methode würde dies bedeuten, wir würden die Basis 10 übergeben und der Exponent wäre der übergebene Parameter.

Und so würde der Java Code dazu aussehen:


public class RundenUebung {
	
	static double rundeZahl(double zahl, int nachKommaStelle){
		zahl = zahl * Math.pow(10, nachKommaStelle); //Kommastelle verschieben = 234533,5545
		zahl = (int) zahl; //Nachkommazahlen streichen = 234533
		zahl = (double) zahl / Math.pow(10, nachKommaStelle); // Nachkommastellen  wieder hinzufügen = 2345,33
		return zahl;		
	}
	
	public static void main(String[] args) {
		System.out.println(rundeZahl(2345.335545, 2));// beim Aufruf wird auch die Nachkommastelle übergeben
		System.out.println(rundeZahl(2345.335545, 5));// 5 Kommastellen
		System.out.println(rundeZahl(2345.335545, 3));// 3 Kommastellen
	}
}

Dies wäre die Standardlösung zum Problem.
De Math.pow Methode berechnet jetzt den Wert anhand des übergebenen Exponenten zur Basis 10.

Aber da ich bei der Aufgabenstellung dir keinen Anhaltspunkt zur Math-Klasse gegeben habe – hast du vielleicht das Problem anders gelöst.

Und zwar mit einer Schleife.

So kannst du die Kommastellen mit einer for-Schleife verschieben.

Im Schleifenkopf lässt du die for-Schleife so oft durchlaufen, wie die übergebene Anzahl an Nachkommastellen.

Der Schleifenzähler i startet bei 1.
Dadurch findet auch die richtige Anzahl an Durchläufen statt.
Der Schleifenzähler wird bei jedem Durchlauf um eins erhöht.

Dies wäre der Schleifenkopf.
for (int i =1; i <= nachKommaStelle; i++)

Im Schleifenrumpf müsste dann ein neuer Wert die entsprechenden Zehnerpotenzen speichern.
Da du diesen Wert auch außerhalb der For-Schleife benötigst, deklarierst du diesen auch außerhalb.

Und diese Variable setzt du dann in deinen bisherigen Code ein.

Und dies wäre der Code zur Umsetzung mit For-Schleife.


public class RundenUebung {
	
	static double rundeZahl(double zahl, int nachKommaStelle){
		int kommaWert=1; //lokale Variable speichert die 10-Potenzen
		for (int i =1; i<=nachKommaStelle; i++){
			kommaWert=10*kommaWert; //Bei jedem Durchlauf mal 10
		}
		
		zahl = zahl * kommaWert; //Kommastelle verschieben = 234533,5545
		zahl = (int) zahl; //Nachkommazahlen streichen = 234533
		zahl = (double) zahl / kommaWert; // Nachkommastellen  wieder hinzufügen = 2345,33
		return zahl;		
	}
	
	public static void main(String[] args) {
		System.out.println(rundeZahl(2345.335545, 2));// beim Aufruf wird auch die Nachkommastelle übergeben
		System.out.println(rundeZahl(2345.335545, 5));// 5 Kommastellen
		System.out.println(rundeZahl(2345.335545, 3));// 3 Kommastellen
	}
}

Da ich die Methoden recht klein halten möchte, lagere ich die for-Schleife in eine separate Methode aus.
Den Rückgabewert binde ich dann in meine bisherige Programmstruktur ein.


public class RundenUebung {
	
	static double rundeZahl(double zahl, int nachKommaStelle){	
		zahl = zahl * gibZehnerPotenz(nachKommaStelle); //Kommaverschiebung wird aus Methode genommen
		zahl = (int) zahl; //Nachkommazahlen streichen = 234533
		zahl = (double) zahl / gibZehnerPotenz(nachKommaStelle);//Kommaverschiebung wird aus Methode genommen
		return zahl;		
	}
	
	static int gibZehnerPotenz(int nachKommaStelle){
		int kommaWert=1; //lokale Variable speichert die 10-Potenzen
		for (int i =1; i<=nachKommaStelle; i++){
			kommaWert=10*kommaWert; 
		}
		return kommaWert;
	}
	
	public static void main(String[] args) {
		System.out.println(rundeZahl(2345.335545, 2));// beim Aufruf wird auch die Nachkommastelle übergeben
		System.out.println(rundeZahl(2345.335545, 5));// 5 Kommastellen
		System.out.println(rundeZahl(2345.335545, 3));// 3 Kommastellen
	}
}

Probier das Ganze an dieser Stelle schon einmal mit ein paar Zahlen und Nachkommastellen aus.

Somit sieht das ganze so ähnlich aus, wie die Umsetzung mit der Math.pow()-Methode.

Es bleibt das letzte Problem.
Die falsche Rundung am Ende.

Lösen wir auch das….

So kannst du bessere Rundungen vollziehen.

Durchdenken wir wieder das Beispiel.

In dem Moment, wo du den Double-Wert in einen Integer castest, streichst du die Nachkommastellen weg.
zahl = (int) zahl;
In jenem Moment brauchst du doch nur analysieren, was du da genau wegstreichst.

Am Beispiel:

  • 234533,5545 minus den gecasteten Integer von 234533.
  • Und der Rest ist irgendwo zwischen 0 und 1.
  • In diesem Fall liegt er bei 0,5545.
  • Und wenn dieser Wert über oder gleich 0,5 ist - dann aufrunden, ansonsten abrunden.

So das wäre der Java Code zur kompletten Runden-Methode.


public class RundenUebung {

	static double rundeZahl(double zahl, int nachKommaStelle){	
		zahl = zahl * gibZehnerPotenz(nachKommaStelle); 
		if (zahl-(int)zahl >=0.5){
			zahl=(int)zahl+1;
		}
		else{
			zahl = (int) zahl; 
		}
		zahl = (double) zahl / gibZehnerPotenz(nachKommaStelle);
		return zahl;		
	}
	
	static int gibZehnerPotenz(int nachKommaStelle){
		int kommaWert=1; 
		for (int i =1; i<=nachKommaStelle; i++){
			kommaWert=10*kommaWert; 
		}
		return kommaWert;
	}
	
	public static void main(String[] args) {
		System.out.println(rundeZahl(2345.335545, 2));
	}
}

Und das wars.
Dieser Methode kannst du jede x-beliebige Zahl übergeben.
Außerdem kannst du dir zu jeder Zahl, x-beliebig viele Nachkommastellen anzeigen lassen.


Ähnliche Beiträge

Der bedeutende Unterschied zwischen Klassenvariablen und Instanzvariablen

Java Klassenvariablen

Bei der Java Programmierung unterscheidet man drei Arten von Variablen. Als erste Gruppe sind die lokalen Variablen zu nennen. Auf diese gehe ich in einem separaten Artikel ein. Mich interessieren die zwei anderen Variablentypen. Zum einen existieren Klassenvariablen. Und dann sind da noch die Instanzvariablen. Wo liegt der Unterschied? Instanzvariablen stehen einem Objekt zur Verfügung. […]

So kannst du Eclipse installieren

Eclipse installieren

Das Schöne an Eclipse ist, es läuft auf sämtlichen Betriebssystemen. Eclipse wird einfach auf der Webseite des Herstellers herunter geladen und kann dann installiert werden. Dabei stehen dir verschiedene Versionen zur Verfügung.

Java Binärzahl in Dezimalzahl umwandeln – So geht’s.

Java-Binärzahl-umrechnen

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem spielt die Zahl 10, als […]

Die vier wichtigen Phasen um Java Objekte zu erstellen

Java Objekte anlegen

Wie werden aus deinen Java Klassen richtig nützliche Java Objekte? Das ganze läuft in vier Phasen ab. Und diese Phasen möchte ich dir in diesem Beitrag vorstellen. Ob das nützlich ist? Schau dir das Bild an. Am Ende dieses Beitrages wirst du wissen, warum Eclipse dir hier eine Fehlermeldung gibt und wie du dieses Problem […]

So lassen sich Java Strings in char zerlegen

Java Strings zerlegen char

Java Strings sind Zeichenketten. Und diese Zeichenketten lassen sich aufsplitten und in ihre Einzelteile zerlegen. Ich möchte dir in diesem Beitrag Möglichkeiten vorstellen, wie du Strings in Character-Datentypen zerlegen, extrahieren und die Einzelteile in Arrays speichern kannst.

So kannst du Java Arrays anlegen

Java Arrays anlegen

Java Arrays– Was ist das? Stell es dir einmal als ein Bücherregal vor. In einem Bücherregal befinden sich sämtliche Bücher. Und diese befinden sich schön nebeneinander. Jedes Buch hat seinen festen Platz. Du kannst die Bücher ganz genau lokalisieren. Zum Beispiel kannst du sagen. Das erste Buch von links Das dritte von rechts usw. Und […]

Java lernen – 10 nützliche Tipps für Java Anfänger

Java Lernen Anfänger

Wenn du die Programmiersprache Java lernen möchtest, bist du hier prinzipiell erst einmal richtig. Und wenn du es wirklich ernst meinst und in die Java Programmierung einsteigen möchtest, solltest du auch meinen kostenlosen Java Kurs beanspruchen. Wenn du dabei bist, bekommst du: Eine Lektion pro Woche zu den Basics. Hier geht es um die ersten […]

So kannst du Java installieren

Java installieren

Bevor du loslegst und deine ersten Java Programme schreibst, benötigst du die entsprechende Arbeitsumgebung. Du solltest also Java installieren. Und diese Arbeitsumgebung beinhaltet dann Bibliotheken für die einzelnen Java-Standard-Klassen, Dateien um deine Programme auszuführen. Dateien um deine Programme zu packen, Logische Verzeichnisstrukturen

Hier sind ein paar richtig nette Features, die dich beim Java lernen unterstützen

Java lernen Eclipse

Was ist das Wichtigste beim Einstieg in ein neues Wissensgebiet? Nein, kein gutes Sachbuch oder ein besonders guter Lehrer. Es ist Spaß. Beim Java Lernen brauchst du Spaß. Es gibt Lehrer, welche ihren Stoff so vermitteln, dass Lernen Spaß bereitet. Aber die Grundvoraussetzung ist und bleibt der Spaß. Und nichts ist so spaßhemmend wie Langeweile […]

3 Möglichkeiten um Vererbung von Java Klassen zu verhindern, zu verbieten oder ausschließen

Java Vererbung verhindern

Die ganze Java Vererbung für bestimmte Klassen ausschließen bzw. verhindern oder verbieten. Was soll das? Für bestimmte Java Klassen soll die Vererbung ausgeschlossen werden. Es soll also verhindert werden, dass Elternklassen – Kindklassen bekommen können. Klingt ein bisschen wie Verhütung, oder? Denn wie auch im echten Leben, können Kinder zu kleinen Tyrannen werden. Sie bedienen […]

Ende vom Java Blog?

Falls du hier schon länger dabei bist, wird dir aufgefallen sein – dass kaum noch Beiträge veröffentlicht werden. Das tut mir wirklich leid und dafür möchte ich mich auch entschuldigen. Ich weiß, dass Einige unter Euch den Java-Blog wirklich lieben. Aber es ist verdammt schwierig so ein aufwendiges Thema – stilvoll, unterhaltend und methodisch umzusetzen. […]