# nach Kommawert einer Zahl



## chrisgl (25. Jul 2005)

Hi!
Bin gerade am basteln und will so learning by doing nen kleinen Rechner schreiben.
Dabei habe ich eine Eingabe aus einem Textfeld die ich in Float umwandle.
Nun wollte ich nur den Teil der Zahl nach dem Komma haben. Also sollte ja Zahl Modulo 1 =^= Zahl%1 für den Rest ja den Wert nach dem Komma ausgeben.
Doch wenn ich zB 12,9 eingebe bekomme 0,900...4 als ausgabe.
Sicherlich liegt das an dem Modulo dachte ich also habe ich eine while schleife geschrieben die immer -1 rechnet solange die Zahl > 1 ist. Auch dort habe ich dieses Ergebnis bekommen.
Kann mir jemand sagen wie ich genau zB 0,9 als Ausgabe bekomme?
Danke MfG Christian

Noch kurz der Code:

    float nachKommaZahl() {
        return(nachKomma=getZahl()%1);
    }

bei getZahl() bekommt er einfach nur den Wert aus der Eingabe


----------



## Beni (25. Jul 2005)

Flieskommazahlen sind ungenau, blabla, Forumsuche + Wikipedia, etc.

Schreib dir eine Methode die nur die ersten Ziffern anguckt, und die letzte ignoriert. Oder guck dir das NumberFormat an, vielleicht kannst du damit was hilfreiches bauen.


----------



## lin (25. Jul 2005)

Könntests dir auch so basteln, dass du zuerst die Nachkommastellen der Zahl die du übergibst, rausholst, bei 12.9 als 1 und diese Zahl dann speicherst.
Dann kannst du dein Modulo ausführen und am Ende wieder auf soviel Nachkommastellen (hier 1) runden.


----------



## L-ectron-X (25. Jul 2005)

Du hast  geschrieben, dass die Eingabe aus einem Textfeld kommt.
Du könntest also die Zeichenkette am Komma trennen, eine 0 vor das Komma setzen und die Stellen nach dem Komma einfach übernehmen.


----------



## chrisgl (26. Jul 2005)

Danke!!!

Für die Anregungen. Das mit dem Abtrennen und dem auslesen der Werte nach Null hab ich auch schon überlegt. Nur bin ich da auf keinen grünen Ast gekommen vielleicht kannst du mir da nochmal helfen. Mit nen Tipp.

Hab ne andere Variante erstmal:

```
float getZahl(){
        eingabeZahl= Float.valueOf( hauptprog.dezimalZahl.getText() ).floatValue();
        return eingabeZahl;
    }
    
    int vorKommaZahl() { 
        return vorKomma = (int) (getZahl());
    }

    int nachKommaZahl() {
        nachKomma = (int)(getZahl()*10000 - vorKommaZahl()*10000);
        return nachKomma;
    }
```

Ist wahrscheinlich nicht so elegant. Hatte zwischen durch schon einige fehler gefunden die ich immer wieder kompensiert habe. Nun sollte die Implentierung passen. 
Aber falls du mir noch nen Tipp zum direckten Auslesen gibst wäre das ganz nett denn ich denke so ist das immer fehlerbehaftet.
Danke !!!!
Chris

Edit: Mist der Fehler liegt im Detail. Kann nur mit max 1000 rechnen weil sonst rundet er also wäre dieses auslesen doch noch sehr viel besser.


----------



## chrisgl (26. Jul 2005)

Und noch ma!
Nach einigen Tests fand ich immer noch Rundungsfehler.
Also hab ich mir mal dran gemacht und das mit diesem auslesen des Strings probiert.
Und siehe da es geht relativ gut nur kann ich zum Schluss nicht einfach int machen. Sondern ich muss die Strings in Float umwandeln und dann in int Casten(ich glaube so nennt man das). Und dann kann ich die als int aus geben. Denn noch paar Exceptions abfangen und jetzt geht es erstmal.....
Hier noch mal der Code:

```
String getZahl(){
        eingabeString=hauptprog.dezimalZahl.getText();
        return eingabeString;
    }

    int kommaPosition() {
        positionKomma=(hauptprog.dezimalZahl.getText()).indexOf(".");       
        System.out.println(positionKomma);
        return positionKomma;
    }

    int vorKommaZahl() { 
        if (positionKomma<0) positionKomma=0;
        vorKommaString=getZahl().substring(0,positionKomma);
        if (vorKommaString.length()==0) vorKommaString="0";
        vorKomma =(int) Float.valueOf( vorKommaString ).floatValue();
        //vorKomma=Integer.parseInt(nachKommaString);
        return vorKomma;    
    }

    int nachKommaZahl() {
        nachKommaString=getZahl().substring(positionKomma+1,getZahl().length());
        nachKomma =(int) Float.valueOf( nachKommaString ).floatValue();
        //nachKomma=Integer.parseInt(nachKommaString);
        return nachKomma;
    }
```

Sieht doch etwas böse aus. Glaube die beiden If's bei vorKommaZahl() kann man zusammen fassen.
Ein Problem ist noch die Ausgabe von zB 45.008 und 45.8 ist gleich für die Nachkommaeinheit. Aber ich glaube da habe ich schon einen Lsg ansatz.
Aber jetzt nicht mehr! Bin verdammt müde.
So dann ich wars
Christian


----------



## anfänger (26. Jul 2005)

deine Substringaufruf in der Nachkomme-Methode ist so nicht ganz richtig. eigentlich müsste dir da eine Exception geworfen werden, weil du auf eine Position zugreifen willst, die dein String gar nicht mehr hat. Bin mir da aber nicht sicher. Bersser ist da aber auf alle Fälle:


```
nachKommaString = getZahl().substring(positionKomma+1);
```

Die Methode geht dann automatisch bis zum letzten Zeichen deines Strings.

Und ich hab dann noch eine Frage. Wieso machst wandelst du deinen Nachkomma-String dann in einen Float um und castest ihn dann in int?
Mach doch dann lieber gleich :

```
nachKomma = Integer.parseInt(nachKommaString);
```

dann hast du gleich ein int- Wert und brauchst nicht mehr hin und her casten


----------



## chrisgl (26. Jul 2005)

Also ich habe jetzt noch etwas rumgedocktert. Stimmt schon Exceptions hatte ich einige und habe sie alle rausbekommen. Hoffe ich. Jedefalls sind bei keinen Testfällen mehr welche erschienen.


```
String getZahl(){
        eingabeString=hauptprog.dezimalZahl.getText();
        return eingabeString;
    }
    
    int kommaPosition() {
        positionPunkt=(hauptprog.dezimalZahl.getText()).indexOf(".");
        positionKomma=(hauptprog.dezimalZahl.getText()).indexOf(",");
        if (positionPunkt>positionKomma) positionKomma=positionPunkt;
        System.out.println(positionKomma);
        return positionKomma;
    }
    
    
    int vorKommaZahl() { 
        if (positionKomma<0) positionKomma=0;
        vorKommaString=getZahl().substring(0,positionKomma);
        if (vorKommaString.length()==0) vorKommaString="0";
        vorKomma =(int) Float.valueOf( vorKommaString ).floatValue();
        return vorKomma;    
    }
   
    int nachKommaZahl() {
        nachKommaString=getZahl().substring(positionKomma+1,getZahl().length());
        nachKommaString=(nachKommaString+nullString).substring(0,9);
        nachKomma =(int) Float.valueOf( nachKommaString ).floatValue();
        return nachKomma;
    }
```

das ding ist wenn ich die gleich mit nen " nachKomma = Integer.parseInt(nachKommaString); " versuche umzuwandeln sagt er mir Exceptions an. Darum habe ich es einfach so probiert und es ging. Bin aber leider net dahinter gestiegen warum dieses parseInt net geht.
Beim substring() muss noch ein Anfang und ein Ende übergeben werden.
Dieses Problem mit den 45.008 und 45.8 wo die Ausgabe gleich war habe ich durch anhängen von 0 gelöst nullString="000000000" dann habe ich einfach alles abgeschnitten was eine bestimmte Länge überschreitet. 
Vielleicht gibt es noch eine elegantere Methode die Nullen ran zubasteln. Wenn ja schreibt mal.
So dann
Christian


----------



## anfänger (26. Jul 2005)

nein. bei suvstring gibt es zwei Methoden. bei einer muss man anfang und ende übergeben und dann gibt es noch eine, bei der nur der anfang übergeben werden muss und dass ist das ende der ende vom string


----------



## chrisgl (26. Jul 2005)

ohhhh gut das wusste ich nicht. tschuldigung wenn ich da etwas vorschnell war.
aber wieso nimmt er dieses parseInt nicht?


----------



## L-ectron-X (26. Jul 2005)

Probiere mal diesen Schnipsel aus.
Hier hast du quasi keine Rundungsfehler, weil nur der eingegebene String bearbeitet wird. Diesen kannst du dann für Berechnungen weiter in Zahlen parsen.

```
import java.io.*;

public class ZahlAbschneiden {
  public ZahlAbschneiden() {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String str = null;
    try {
      System.out.print("Gib eine Zahl ein! ");
      str = in.readLine();
      str = abschneiden(str);
      str = formatieren(str);
      System.out.println("Die erzeugte Zahl lautet: "+str);
    }
    catch(IOException e) {
       System.out.println("Fehler bei Eingabe!");
    }
    catch(ArrayIndexOutOfBoundsException ex) {
      System.out.print("Starte neu und gib eine Kommazahl ein!");
    }
  }
  
  private String abschneiden(String str) throws ArrayIndexOutOfBoundsException {
    String[] strArr = str.split(",");
    return strArr[1];
  }
  
  private String formatieren(String str) {
    return "0,"+str;
  }

  public static void main(String[] args) {
    new ZahlAbschneiden();
  }
}
```


----------



## messi (27. Jul 2005)

Schau dir auch mal *java.math.BigDecimal* an, wenn du auf solche Feinheiten Wert legst.


----------



## chrisgl (28. Jul 2005)

Vielen Dank für die zahlreichen und sehr guten Vorschläge!
Mein Problem sehe ich als gelöst an.
MfG Christian


----------



## L-ectron-X (29. Jul 2005)

Vielleicht schreibst du ja noch, wie deine Lösung aussieht?


----------



## chrisgl (29. Jul 2005)

Klar kann ich.
Hab noch mal das ausprobiert was hier so stand. Aber bin dann beim Folgenden geblieben. Rundet nicht mehr und ist genau.


```
String getZahl(){
        eingabeString=hauptprog.dezimalZahl.getText();
        return eingabeString;
    }
    
    int kommaPosition() {
        positionPunkt=(hauptprog.dezimalZahl.getText()).indexOf(".");
        positionKomma=(hauptprog.dezimalZahl.getText()).indexOf(",");
        if (positionPunkt>positionKomma) positionKomma=positionPunkt;
        System.out.println(positionKomma);
        return positionKomma;
    }
    
    
    int vorKommaZahl() { 
        if (positionKomma<0) {
            positionKomma=getZahl().length();
            keinNachKomma=true;
        } else {
            keinNachKomma=false;
        }
        vorKommaString=getZahl().substring(0,positionKomma);
        if (vorKommaString.length()==0) vorKommaString="0";
        vorKomma =(int) Float.valueOf( vorKommaString ).floatValue();
        return vorKomma;    
    }
   
    int nachKommaZahl() {
        if (keinNachKomma==true){
            nachKomma=0;
        } else {
            nachKommaString=getZahl().substring(positionKomma+1);
            nachKommaString=(nachKommaString+nullString).substring(0,9);
            nachKomma =(int) Float.valueOf( nachKommaString ).floatValue();
        }
        return nachKomma;
    }
```


----------

