Wert eines Strings berechnen

[shigoro]

Hallo Zusammen

Wenn ich z.B. folgenden String habe "3+5"

Kann ich den dann irgendwie in einen double mit dem entsprechenden Wert, in diesem Fall 8 umwandeln?

Zuerst dachte ich es funktioniert einfach mit

double result = Double.parseDouble("3+5");

Das geht jedoch nicht...

Gruss shigoro

 

[DesertFox]

schau dir mal StringTokenizer an. Die einzelnen Tokens kannst du dann in Doubles Parsen und dann berechnen

 

[thE_29]

weil du einen String addieren willst???

Gib mal das Bsp aus deinem Programm, weil so ein Bsp braucht keiner, da schreibt jeder Double.parseDouble("8") hin!


Nachtrag: versteh jetzt was du meinst, du willst das sich die Zahlen zusammen zählen

Könntest via Tokenizer, oder Split machen, nur gibts da halt immer nur 1 Zeichen!

 

[The_S]

Spontan:

String aufteilen

[edit] Verflucht! Schon wieder zu langsam

 

[Guest]

Ja die Grundidee mit dem StringTokenizer ist schon mal gut... Jedoch benötige ich das Ganze für einen Taschenrechner.

Und da kann beispielsweise auch mal so ein String "3+5-2*6" vorkommen. Und dann lässt sich das ganze ja nicht mehr mit StringTokenizer lösen, oder besser gesagt ich weiss nicht wie :roll:

Gruss Shigoro

 

[Bleiglanz]

dieses Problem hat sooooooooooooo einen Bart

String s = " 3+(4*17)-36/6 ";

gesucht ist eine Funktion

public double eval(String s){

}

ist in diversen Skriptsprachen eingebaut (Perl, PHP); in Java musst du das wohl selbst machen

// editiert, rückgabetyp müsste natürlich double sein

 

[thE_29]

public static eval(String s){

}


ERRRR:::

Die Funktion würde net gehen, außer sie isn Konstruktor

Aber, tjo musst selbst implementieren!

Ich würds rekursiv machen!

Nur bin ich zz zu faul, bzw hab keine Zeit um mir das genauer anzusehen!

 

[meez]

Hier eine ziemlich primitive Implementierung einer Rechnerklasse...(Unterstützt aber keine Klammern)
Aber du kannst z.B. sowas Rechnen: 3+4*25+3/7+4^27

double result = new SimpleCalculator().calculate("3+4*25+3/7+4^27");

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class SimpleCalculator {

	public SimpleCalculator() {}

	/**
	 *  + = addition 
         *   - = subtraction * = multiplication
         *  / = division ^ = power (pow) 
         *  % = square-root e.g 2%4 = 2
	 *  
	 */
	public double calculate(String expression) {
		if (expression == null) return Double.MIN_VALUE;
		expression = expression.trim();
		if (expression.equals("")) return Double.MIN_VALUE;		
		StringTokenizer str = new StringTokenizer(expression, "+-*/^%", true);
		List tokens = new ArrayList(str.countTokens());
		w : while (str.hasMoreTokens())
			tokens.add(str.nextToken().trim());
		w : while (tokens.indexOf("%") > -1) {
			f : for (int n = 0; n < tokens.size(); n++)
				calculate("%", tokens, n);
		}
		w : while (tokens.indexOf("^") > -1) {
			f : for (int n = 0; n < tokens.size(); n++)
				calculate("^", tokens, n);
		}
		w : while (tokens.indexOf("*") > -1) {
			f : for (int n = 0; n < tokens.size(); n++)
				calculate("*", tokens, n);
		}
		w : while (tokens.indexOf("/") > -1) {
			f : for (int n = 0; n < tokens.size(); n++)
				calculate("/", tokens, n);
		}
		w : while (tokens.indexOf("-") > -1) {
			f : for (int n = 0; n < tokens.size(); n++)
				calculate("-", tokens, n);
		}
		w : while (tokens.indexOf("+") > -1) {
			f : for (int n = 0; n < tokens.size(); n++)
				calculate("+", tokens, n);
		}
		if (tokens.size() != 1) return Double.MIN_VALUE;
		return toDouble((String) tokens.get(0),  Double.MIN_VALUE);
		
	}

	private void calculate(String calcType, List tokens, int n) {
		String token = (String) tokens.get(n);
		if (!token.equals(calcType)) return;
		double l, r, res;
		int s, e;
		if (n - 1 == -1) {
			s = 0;
			l = 1;
		} else {
			s = n - 1;
			l = toDouble((String) tokens.get(n - 1), 1);
		}
		if (n + 1 == tokens.size()) {
			e = tokens.size() - 1;
			r = 1;
		} else {
			e = n + 1;
			r = toDouble((String) tokens.get(n + 1), 1);
		}
		if (calcType.equals("%"))
			res = Math.sqrt(r);
		else if (calcType.equals("^"))
			res = Math.pow(l, r);
		else if (calcType.equals("*"))
			res = l * r;
		else if (calcType.equals("/"))
			res = l / r;
		else if (calcType.equals("-"))
			res = l - r;
		else if (calcType.equals("+"))
			res = l + r;
		else
			res = 0;
		tokens.add(e + 1, String.valueOf(res));
		f : for (int i = e; i >= s; i--)
			tokens.remove(i);
		n = n + (e - s);

	}

	private double toDouble(String number, double defaultNumber) {
		try {
			return Double.parseDouble(number);
		} catch (NumberFormatException e) {}
		return defaultNumber;
	}	
}

 

[thE_29]

Was ist das w: und f: bitte??

 

[meez]

Der Schleifen-Identifier...
Das mach ich immer.... ist aber meist nicht nötig...

 

[shigoro]

Vielen Dank!

So funktioniert es

 

[foobar]

Was ist das w: und f: bitte??

Juhu endlich gibts in Java auch Spagetti-Code ;-)

 

[meez]

Juhu endlich gibts in Java auch Spagetti-Code

:?:
Das ist keine Sprungmarke sondern, wie gesagt, der Schleifenbezeichner...
(Sieht dort halt etwas seltsam aus, weils gleich soviele sind)...

So zu gebrauchen:

f1 : for (...) {
   f2 : for (...) {
      if (...) continue f1;
   }
}

 

[thE_29]

die braucht man aber überhaupt nie oder??

Gehts ohne dem auch, wenn ja gewöhn dir das ab, sieht ja schrecklich aus!

Wie labls und gotos, paa

 

[Illuvatar]

Na hin und wieder finde ich es auch äußerst sinnvoll, eine weiter äußere Schleife abzubrechen/fortzufahren, oder in großen Schleifen diese einfach nur der Verständlichkeit halber zu benennen. Allerdings finde ich, dass es so, wie meez es macht, schon eher unleserlicher wird

 

[meez]

Das Beispiel ist auch ohne die Bezeichner unleserlich, da es 7 while Schleifen mit je einer for Schleife hat...
Ich habe mir halt angewöhnt, den Bezeichner immer gleich am Anfang zu schreiben....