Rechenoperatoren mit Regex splitten

[imox]

Hallo,

ich versuche gerade mit einem String zu rechnen.

		String result = "111.5+2.5-5.5*88.99/5588.555";
		String zahlen[] = result.split("[^0-9.]");

		for (int i = 0; i < zahlen.length; i++) {
			System.out.println(zahlen[i]);
		}

Damit bekomm ich die ganzen zahlen raus:


111.5
2.5
5.5
88.99
5588.555


Aber ich bekomm das nicht hin mir die Operatoren raus zu splitten. Kann mir jemand sagen wie das geht?

 

[julian.veh]

Hi

so weit ich weiß, musst du den String dazu mit einem Parser parsen.
Ich habe mal einen Taschenrechner geschrieben und da mir dies zu komplex war habe ich einfach ein Java Script Engine verwendet. Das ist dann ziemlich simpel 😉

Grüße

 

[imox]

hmmm ok danke und wie mach ich das ^^ ?

 

[nrg]

geht mit regex schon auch aber ich würde hier eher zu einem simplen parser tendieren. wenns leicht sein soll, vllt. auch zur scriptingengine

[EDIT]
Parser:
http://www.java-forum.org/allgemeines/12306-parser-fuer-mathematische-formeln.html

Scripting Engine:
Scripting for the Java Platform[/EDIT]

 

[imox]

und wie würde das mit regex gehen? das schau ich mir mal an aber für die Schule muss ich das leider mit regex können ;(

 

[julian.veh]

regex = regular expressions

Kannst du ja mal googlen 🙂.

@nrg Ich wollte gerade dein Bild töten ^^

 

[imox]

ja hab ich schon getan nix gefunden sonst würde ich hier nicht fragen

 

[julian.veh]

Lesson: Regular Expressions (The Java™ Tutorials > Essential Classes)

hilft dir das? =)

 

[imox]

nein das hab ich ja schon gelesen, damit hab ich ja auch die zahlen rausbekommen aber wie ich die anderen Zeichen rausbekomme versteh ich nicht sorry.

 

[nrg]

du musst die Paare herausfinden, die zuerst berechtet werden sollen:

operantoperatoroperant

dafür hast du die regex ja schon - fehlt nurnoch der operator (wobei die regex nicht 100% passt). dann kannst du das splitten, die operanten in doubles parsen, berechnen und in den string replacen. wenn der operator nicht mehr exisitiert, gehst du weiter zum nächsten - bis der String keine operatoren mehr enthält.

 

[imox]

hmm also geht's doch nicht mit regex oder wie? bin jetzt verwirrt und kann mir das auch nicht so richtig vorstellen. kann mir jemand mal eine Beispiel zeigen?

 

[julian.veh]

Dazu kann ich nicht viel sagen ^^ sry.

Falls du auf die Methode mit dem Java Script Engine zurückkommen willst

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("javascript");
String a = tf1.getText();
try {
Object o = engine.eval(a);
} catch(ScriptException e) {
}

 

[nrg]

hier ein kleines Beispiel mit Regex:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMathParser {

	private static final String DBL_REGEX = "[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?";
	private static final char[] OPERATORS = {'*', '/', '+', '-'};

	public double parse(String formula) {
		for (char operator : OPERATORS)
			formula = parse(formula, operator);
		
		if (!formula.matches(DBL_REGEX))
			throw new RuntimeException("unknown error in formula " + formula);
		
		return Double.parseDouble(formula);
	}

	private String parse(String formula, char operator) {
		Pattern p = Pattern.compile(DBL_REGEX + "\\" + operator + DBL_REGEX);
		Matcher m = p.matcher(formula);
		while (m.find()) {
			String group = m.group();
			String[] operands = group.split("\\" + String.valueOf(operator));
			String result = String.valueOf(calc(operands[0], operands[1], operator));
			formula = formula.replace(group, result);
		}
		return formula;
	}

	private double calc(String firstOp, String secondOp, char operator) {
		switch (operator) {
		case '*': return Double.parseDouble(firstOp) * Double.parseDouble(secondOp);
		case '/': return Double.parseDouble(firstOp) / Double.parseDouble(secondOp);
		case '+': return Double.parseDouble(firstOp) + Double.parseDouble(secondOp);
		case '-': return Double.parseDouble(firstOp) - Double.parseDouble(secondOp);
		default: throw new IllegalArgumentException("invalid operator " + operator);
		}
	}
	
	// Test
	public static void main(String[] args) {
		System.out.println(new RegexMathParser().parse("111.5+2.5-5.5*88.99/5588.555"));
	}
}

könnte man z.b. auch rekursiv machen. Jetzt kann der parser aber nur punkt-vor-strich. Wenn jetzt noch klammern dazukommen, wird es schon wieder bisschen umständlicher und man greift doch lieber zu einem top-down parser.