# Wert eines Strings berechnen



## shigoro (20. Jan 2005)

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 (20. Jan 2005)

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


----------



## thE_29 (20. Jan 2005)

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 (20. Jan 2005)

Spontan:

String aufteilen

[edit] Verflucht! Schon wieder zu langsam


----------



## Guest (20. Jan 2005)

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 (20. Jan 2005)

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 (20. Jan 2005)

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 (20. Jan 2005)

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 (20. Jan 2005)

Was ist das w: und f: bitte??


----------



## meez (20. Jan 2005)

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


----------



## shigoro (20. Jan 2005)

Vielen Dank!

So funktioniert es


----------



## foobar (20. Jan 2005)

> Was ist das w: und f: bitte??


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


----------



## meez (21. Jan 2005)

foobar hat gesagt.:
			
		

> 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 (21. Jan 2005)

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 (21. Jan 2005)

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 (21. Jan 2005)

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....


----------

