# Runden auf 2 Nachkommastellen klappt nicht||| WARUM



## CentroN (18. Okt 2005)

```
import java.io.*;
import java.lang.*;
import java.math.*;
import java.text.*;

public class Election {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    	if (args.length != 6) {
    		System.out.println("Bitte geben Sie die Stimmen von 6 Parteien an!! Programm terminiert");
    		System.exit(1);
    	}
    	
    	String EingabeWert;
        int GesamtZahl = 0, x = 0, y = 0;
        int[] WerteArray = new int[6];
        double[] ProzeArray = new double[6];;
        // TODO code application logic here
        System.out.println("Eingabeauswertung hat begonnen");
        for (x = 0; x < WerteArray.length; x++) {
        	EingabeWert = args[x];
                    if (Kontrolle(EingabeWert) == false) {
                    	System.exit(1);
                    }
             WerteArray[x] = Integer.parseInt(args[x]);
             GesamtZahl += WerteArray[x];
        }
        
        for (x = 0; x < ProzeArray.length; x++) {
            //MakroAufruf
            ProzeArray[x] = roundEvenexp2((WerteArray[x] * 100.00 ) / GesamtZahl);
            //Debugzeile
            System.out.println(ProzeArray[x]);
        }            
    }
    
    //RoundMakro
     static double roundEvenExp2 (double d) {
   		return round (d, 2, HALF_EVEN, FormatType.exp);
    }
    
    /**
    * @param  d der zu rundende Gleitkommawert.
    * @param  scale die Anzahl der Nachkommastellen, falls type = fix,
    *         die Anzahl der tragenden Stellen - 1,  falls type = exp.
    *         scale sollte >= 0 sein (negative Werte werden auf 0 gesetzt).
    * @param  mode die Rundungsart: einer der Rundungsarten von BigDecimal,
    *         seit 1.5 in java.math.RoundingMode.
    * @param  type ein Element von "enum FormatType {fix, exp}" gibt an,
    *         auf welche Stellen sich die Rundung beziehen soll.
    *         FormatType.exp ('Exponential') steht für tragende Stellen,
    *         FormatType.fix ('Fixkomma') steht für Nachkommastellen.
    * @return der gerundete Gleitkommawert.
    * 

Anmerkung: Für die Werte <tt>double</tt> NaN und &Infinity
    * liefert round den Eingabewert unverändert zurück.
    */
     public static double round (double d, int scale, RoundingMode mode, FormatType type) {
        if (Double.isNaN(d) || Double.isInfinite(d)) return d;
        scale = Math.max(scale,0);  // Verhindert negative scale-Werte
        BigDecimal bd = BigDecimal.valueOf(d);
        if (type == FormatType.exp) {
            BigDecimal bc = new BigDecimal(bd.unscaledValue(),bd.precision()-1);
            return ((bc.setScale(scale, mode)).
            scaleByPowerOfTen(bc.scale()-bd.scale())).doubleValue();
        }
        return (bd.setScale(scale, mode)).doubleValue();
    }

 
    
    /**
     * Wenn die mitgelieferten Parameter nicht einer Zahl entsprechen,
     * dann endet das Programm normal durch try/ catch Anweisungsblöcke 
     */
    static boolean Kontrolle (String A) {
        int i;
        try 
        {
            i = Integer.parseInt(A);
            if (i >= 0) return true;
                else return false;
        }
        
        catch (Exception e) {
        	System.out.println("Wert " +A +" wurde nicht akzeptiert");
        	return false;
        }         
    }
}
```

Kann mir jemand sagen warum ich im Compiler immer nur cant´t find FormatType, rountEvenexp2 oder HALF_EVEN lesen muss und warum es nicht tut. Gibts kleinere Methoden zum runden auf 2 Nachkommastellen.


----------



## Gast (18. Okt 2005)

Versuche das hier
	
	
	
	





```
Math.round(doubleValue*100.0d)/100.0d
```


----------



## CentroN (18. Okt 2005)

Gast hat gesagt.:
			
		

> Versuche das hier
> 
> 
> 
> ...





```
for (x = 0; x < ProzeArray.length; x++) {
            y = (WerteArray[x] * 100) / GesamtZahl;
            y = Math.round((y*100.d)/100.0d);
            ProzeArray[x] = y;
            //Debugzeile
            System.out.println(ProzeArray[x]);
        }
```

Hab jetzt den langen Klabimsel entfernt. So gibts auch einen Fehler weiß also nicht wie ich das einbauen soll da ich ja nicht schreiben kann GesamtZahl.0d oder so etwas ;o)


[/quote]


----------



## L-ectron-X (18. Okt 2005)

> So gibts auch einen Fehler weiß also nicht wie ich das einbauen soll...


Wie lautet die Meldung?

Vielleicht findest du hier die passende Lösung:
http://www.java-forum.org/de/viewtopic.php?t=11339


----------



## SnooP (18. Okt 2005)

100.d? ... wenn 100.0d - aber bei 100.0 wird automatisch double genommen - das d kannte ich in der Verbindung mit Double bislang gar nisch... - also schreib einfach 100.0


----------



## CentroN (18. Okt 2005)

Election.java:49: possible loss of precision
found   : long
required: int
            y = Math.round((y*100.d)/100.0d);
                          ^
1 error

Das ist die Meldung

Nun hab ich mir gedacht, dass man das vielleicht so hinbekommen kann aber leider nix


```
for (x = 0; x < ProzeArray.length; x++) {
           
            ProzeArray[x] = (float)((int)((WerteArray[x] * 100) / GesamtZahl) * 100.0d)/(float)100.0d;
            //Debugzeile
            System.out.println(ProzeArray[x]);
        }
```


----------



## L-ectron-X (18. Okt 2005)

> (float)100.0d


...das ist Unsinn.
Wenn du möchtest, dass die Zahl vom Typ float ist, kannst du das so festlegen:

```
float f = 100.0f;
```

Aber das ist natürlich noch nicht die Lösung zu deinem Problem.


----------



## CentroN (18. Okt 2005)

Ich bekomme immer 9.0 oder so etwas also meine Nachkommastellen sind immer 0.

Wie löse ich das,


----------



## L-ectron-X (18. Okt 2005)

Bist du mal meinem Link gefolgt? Dort gibts ausreichend Vorschläge.
Von welchem Typ ist denn y ?


----------



## CentroN (18. Okt 2005)

```
for (x = 0; x < ProzeArray.length; x++) {
           
            ProzeArray[x] = (((WerteArray[x] * 100) / GesamtZahl) * 100.0f)/100.0f;
            //Debugzeile
            System.out.println(ProzeArray[x]);
        }
```

So sieht die Funktion aus und es sollen die Werte aus einem IntArray durch die komplizierte Berechnung ;o) als Float in ein Float Array und zwar genau mit 2 Nachkommastellen.[/quote]


----------



## L-ectron-X (18. Okt 2005)

Zahlen vom Typ int haben keine Stellen nach dem Komma, daher macht auch eine Rundung keinen Sinn. Du wirst bei einer Umwandlung in einen Typ double/float immer als Nachkommastelle eine 0 bekommen.
Aus einem int-Wert kannst du so ein float-Wert machen:

```
float f = Integer.valueOf(120).floatValue();
```


----------



## Guest (18. Okt 2005)

```
float nochNeGesamtzahl = (float)GesamtZahl;
```
und verwende nochNeGesamtzahl statt Gesamtzahl. 

So wie Du es hast, wird zuerst eine Ganzzahldivision durchgeführt, 
bei der die Nachkommastellen nicht berücksichtigt werden.


----------



## CentroN (18. Okt 2005)

```
for (x = 0; x < ProzeArray.length; x++) {
            System.out.println(WerteArray[x]);
            ProzeArray[x] = Math.round(((WerteArray[x] * 100.0f) / GesamtZahl) * 100.0f);
            System.out.println(ProzeArray[x]);
            ProzeArray[x] = ProzeArray[x]/100.0f;
            //Debugzeile
            System.out.println(ProzeArray[x]);
        }
```

So siehts jetzt aus und es klappt PRIMA


----------



## Sky (19. Okt 2005)

Sag mal, ist es dein Ziel den Wert der Zahl zu ändern oder geht es nur darum die Zahl mit 2 Nachkommastellen anzuzeigen!? Wenn es nur um die Anzeige geht: 
	
	
	
	





```
NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(2);
System.out.println(nf.format(zahl));
```


----------

