String "1+1" zu double

[pzypher]

Hallo,

ich weiß grundsätzlich wie man Datentypen konvertiert (oder dachte ich weiß es), jedoch hab ich hier ein Problem:

        String a = "1+1";

        double d;

        d = Double.parseDouble(a);

        System.out.println(d);

Exception in thread "main" java.lang.NumberFormatException: For input string: "1+1"
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1242)
at java.lang.Double.valueOf(Double.java:492)

Wenn ich nur "1" als String hätte, würds ja gehen. Aber wie schauts mit einer Berechnung aus?

 

[HimBromBeere]

"1+1" ist halt erstmal nur eine Zeichenkette.

Einen Taschenrechner zu programmieren, ist nicht ganz so trivial wie du es hier schreibst. Du musst schon die verschiedenen Operanden und Operatoren getrennt einlesen, also dir einen Kopf machen, wie du das Plus-Zeichen einliest, welche Bexeutung eine Zahl innerhalb der Zeichenkette hat...

 

[XHelp]

Wenn du

1+1

zu

2

machen, willst, dann musst du richtung Funktionsparser suchen. Es gibt hier im Forum einige Themen dazu

 

[pzypher]

Richtig, es soll ein kleiner Taschenrechner inkl. GUI werden. Habs auch schon hinbekommen (Operand1/2 + Operation aus dem String mit Schleifen auslesen), aber ich dachte mir halt es geht sicherlich eleganter.

/*
* Code ist nicht vollständig (GUI etc. fehlt)
* 
*/

    double operand1;
    double operand2;
    int stringIndex = 0;

    String ausgabeValue = "";
    String op1 = "";
    String op2 = "";
    //ausgabe = jTextField


    char operation = 'x';

    private void resultButtonActionPerformed(java.awt.event.ActionEvent evt) {

        while(true) {

            ausgabeValue = ausgabe.getText();

            /*
             * Behandelt den Fall wenn Vorzeichen im Ausdruck sind
             */
            if(ausgabeValue.charAt(stringIndex)=='-' || ausgabeValue.charAt(stringIndex)=='+' ) {
                op1+=ausgabeValue.charAt(stringIndex);
                stringIndex++;
            }

            /*
             * Behandelt den Fall wenn keine Operation im Ausdruck ist (Fehlermeldung)
             */
            if(!ausgabeValue.contains("+") & !ausgabeValue.contains("-") & !ausgabeValue.contains("*") & !ausgabeValue.contains("/")) {
                JOptionPane.showMessageDialog(this, "Fehlerhafter Ausdruck!","Fehler", JOptionPane.ERROR_MESSAGE);
                ausgabe.setText(null);
                ausgabeValue = null;
                break;
            }

            /*
             * Zerlegt den String in Operand 1 (=String)
             */
            while(ausgabeValue.charAt(stringIndex)!='+' & ausgabeValue.charAt(stringIndex)!='-' & ausgabeValue.charAt(stringIndex)!='*' & ausgabeValue.charAt(stringIndex)!='/' ) {
                op1+=ausgabeValue.charAt(stringIndex);
                stringIndex++;
            }

            /*
             * Umwandlung von Op1 (=String) zu Operand1 (=double)
             */
            try {
            operand1 = Double.parseDouble(op1);
            } catch (java.lang.NumberFormatException op1) {
                JOptionPane.showMessageDialog(this, "Fehlerhafter Ausdruck!","Fehler", JOptionPane.ERROR_MESSAGE);
                ausgabe.setText(null);
                ausgabeValue = null;
                break;
            }

            operation = ausgabeValue.charAt(stringIndex);
            stringIndex++;

            /*
             * Übermittelt den restlichen String nach Op1 (=String)
             */
            for(;stringIndex < ausgabeValue.length(); stringIndex++) {
                op2 += ausgabeValue.charAt(stringIndex);
            }

            /*
             * Umwandlung von Op2 (=String) zu Operand2 (=double)
             */
            try {
            operand2 = Double.parseDouble(op2);
            } catch (java.lang.NumberFormatException op2) {
                JOptionPane.showMessageDialog(this, "Fehlerhafter Ausdruck!","Fehler", JOptionPane.ERROR_MESSAGE);
                ausgabe.setText(null);
                ausgabeValue = null;
                break;
            }

            /*
             * Entscheidung welche Rechenoperation ausgeführt wird
             */

                    switch(operation) {
                    case '+':
                        ausgabe.setText(String.valueOf(operand1+operand2);
                        break;
                    case '-':
                        ausgabe.setText(String.valueOf(operand1-operand2));
                        break;
                    case '*':
                        ausgabe.setText(String.valueOf(operand1*operand2));
                        break;
                    case '/':
                        if(operand2!=0) {
                            ausgabe.setText(String.valueOf(operand1/operand2));
                            break;
                        }
                        else {
                            JOptionPane.showMessageDialog(this, "Durch 0 darf nicht dividiert werden!","Fehler", JOptionPane.ERROR_MESSAGE);
                            break; }
                    default:
                            break;
                }
                    break;
        }

        stringIndex = 0;
        ausgabeValue = ausgabe.getText();
        op1 = "";
        op2 = "";
        
    }

 

[timbeau]

Eine Konvertierung beinhaltet keine Logik sondern nur eine Änderung der "Schablone" wie der Wert zu sehen ist. Z.B. "1" + "1" = "11".

 

[ARadauer]

oder von JavaScript machen lassen....

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class Rechner {
 
 public static void main(String[] args) throws IOException {
  BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
  
  System.out.print("Formel eingeben: ");
  String formel = r.readLine();
         ScriptEngineManager factory = new ScriptEngineManager();
         ScriptEngine engine = factory.getEngineByName("JavaScript");
          
        
         try {
    engine.eval("var v = eval('"+formel+"')");
    double b =(Double) engine.get("v");

          System.out.println("Ergebnis: "+b);
   } catch (ScriptException e) {
    System.out.println("Das war wohl nix");
    e.printStackTrace();
   }       
        
     }
 }

 

[AquaBall]

Und von der anderen Seite betrachtet:

Double.parseDouble(a) macht eine Zahl aus einem String,
Tut also was es sagt: "macht eine Zahl."
Da steht nirgends was von: "führt Berechnungen aus."

Und weil "1+1" keine gültige Zahl ist kann der Parser nicht damit machen.
Eine Zahl besteht ausschließlich aus Ziffer, und evtl 1 einzigen ".", sonst nichts.

 

[vimar]

Also ich würds so machen:

mit einem StringTokenizer.

String a = "1+1+23-5+23-12+34";

String temp;
ArrayList <Double> ZahlenListe = new ArrayList();
ArrayList <String>  PlusMinusMalDurchListe =  new ArrayList();


StringTokenizer StrToKen = new StringTokenizer(a);

while (StrToKen.hasMoreTokens()){
   temp = StrToKen.nextToken();
       
       if(temp.equals("+")) PlusMinusMalDurchListe.add("+");
       else if(temp.equals("-")) PlusMinusMalDurchListe.add("-");
        else if(temp.equals("*")) PlusMinusMalDurchListe.add("*");
        else if(temp.equals("/")) PlusMinusMalDurchListe.add("/");
        else { // ist ne zahl dann -.-
            ZahlenListe.add(Double.parseDouble(temp));
           }

}

// jetzt hätten wir 2 arraylisten
        
      int ZahlenCounter= 0;
      int operationCounter=0;

// hier jetzt ne for schleife für die arraylisten in dem sinne

if (PlusMinusMalDurchListe.get(0).equals("+") additionsMethode(ZahlenListe.get(0),ZahlenListe.get(1)); // usw

 

[pzypher]

Danke für eure Antworten.

Hab noch 2 Fragen:

Das Javascript von ARadauer ist ja um einiges kürzer (und eleganter?) als meine bzw. die von vimar, gibts da irgendwelche Nachteile bei der Verwendung von JS bzw. worauf muss man aufpassen wenn man dies verwendet?

Warum gibts eine solche Funktion

engine.eval("var v = eval('"+formel+"')");

nicht auch bei Java?

 

[AquaBall]

Mit JavaScript schreibst du halt keine Programme, sondern nur einen Stapel an Befehlen.

Das hat zwar schon ein Bisschen mit Programmieren zu tun, aber das Ergebnis ist kein Programm.
Da bist du weit davon entfernt ein Programmierer zu sein.

Aber wenn es deine Anforderungen reicht, dann mach es so.