Resolver operaciones String

[Jrt_1990]

Buenas, tengo una duda acerca de String y Double.
La cosa es que necesito resolver unas operaciones que paso a un método por una String, lo que hago es sustituir dentro de la String la X por el valor que le corresponde y después con "Double.valueOf(La String).doubleValue();" que me devuelva el Double, pero no funciona a menos que sea un número.
Os pongo un ejemplo:

public class pruebas {

public static void main(String [] args){

String S = new String("x+x");
System.out.println(S);
S = S.replaceAll("x", "2");
System.out.println(S);
double numero=Double.valueOf(S).doubleValue();;
System.out.println(numero);
}
}

Pero... da error... ¿Alguna idea? Muchas gracias

[webness]

el metodo valueOf(string); recibe una cadena de caracteres pero estos deben de ser numeros validos. el resto te sobra, en este caso debes de utilizar el equivalente en java de una funcion de otros lenguajes que se llama eval(string); ella lo que hace es evaluar esa cadena como una operacion matematica y devulve el resultado, pero JAVA no la tiene, toca que baje una libreria o algo que ya tenga implementada esta funcion:

http://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/evaluating-expressions-with-java

o que tu mismo hagas el algoritmo.

[Jrt_1990]

Muchas gracias, voy a ver si dividiendiendo la String y con recursividad funciona!! xD

[Jrt_1990]

Creo que ya lo he conseguido, por si alguien lo va a necesitar alguna vez:

Código:

		public String calculo(String a, String b, String o) {
		if(o == "*")
			return String.valueOf(((Double.valueOf(a).doubleValue())*(Double.valueOf(b).doubleValue())));
		if(o == "/")
			return String.valueOf(((Double.valueOf(a).doubleValue())/(Double.valueOf(b).doubleValue())));
		if(o == "+")
			return String.valueOf(((Double.valueOf(a).doubleValue())+(Double.valueOf(b).doubleValue())));
		if(o == "r")
			return String.valueOf(((Double.valueOf(a).doubleValue())-(Double.valueOf(b).doubleValue())));
		if(o == "¬")
			return String.valueOf(Math.sin(Math.toRadians(Double.valueOf(a))));
		if(o == "#")
			return String.valueOf(Math.cos(Math.toRadians(Double.valueOf(a))));
		if(o == "&")
			return String.valueOf(Math.tan(Math.toRadians(Double.valueOf(a))));
		return "0.0";
		}
		
	public String dividir(String s) {
	int p1=0;
	int p2=0;
	String sub = "";
	String sub2 = "";
	String sub3 = "";
		
	if(s.indexOf('+') >= 0 && s.indexOf('(') < 0 && s.indexOf(')') < 0) {
		for(int i = 0; i < s.length()&&s.indexOf('+', i) >= 0; i++) {
			p1=s.indexOf('+', i);
			sub=this.dividir(s.substring(0, p1));
			sub2 = this.dividir(s.substring(p1+1));
		}
			s = this.calculo(this.dividir(sub), this.dividir(sub2), "+");
	}
	
	if(s.indexOf('r') >= 0 && s.indexOf('(') < 0 && s.indexOf(')') < 0) {
		System.out.println(s);
		for(int i = 0; i < s.length()&&s.indexOf('r', i) >= 0; i++) {
			p1=s.indexOf('r', i);
			sub=this.dividir(s.substring(0, p1));
			sub2 = this.dividir(s.substring(p1+1));
		}
			s = this.calculo(this.dividir(sub), this.dividir(sub2), "r");
	}
	if(s.indexOf('*') >= 0 && s.indexOf('(') < 0 && s.indexOf(')') < 0) {

		for(int i = 0; i < s.length()&&s.indexOf('*', i) >= 0; i++) {
			p1=s.indexOf('*', i);
			sub=this.dividir(s.substring(0, p1));
			sub2 = this.dividir(s.substring(p1+1));
		}
			s = this.calculo((sub), (sub2), "*");
	}
	
	if(s.indexOf('/') >= 0 && s.indexOf('(') < 0 && s.indexOf(')') < 0) {
		for(int i = 0; i < s.length()&&s.indexOf('/', i) >= 0; i++) {
			p1=s.indexOf('/', i);
			sub=this.dividir(s.substring(0, p1));
			sub2 = this.dividir(s.substring(p1+1));
		}
			s = this.calculo((sub), (sub2), "/");
	}
	
	if(s.indexOf('¬') >= 0 && s.indexOf('(') < 0 && s.indexOf(')') < 0) {
		for(int i = 0; i < s.length()&&s.indexOf('¬', i) >= 0; i++) {
			p1=s.indexOf('¬', i);
			sub=this.dividir(s.substring(p1+1));
		}
		System.out.println(sub);
			s = this.calculo((sub), null, "¬");
	}
	
	if(s.indexOf('#') >= 0 && s.indexOf('(') < 0 && s.indexOf(')') < 0) {
		for(int i = 0; i < s.length()&&s.indexOf('#', i) >= 0; i++) {
			p1=s.indexOf('#', i);
			sub=this.dividir(s.substring(p1+1));
		}
		System.out.println(sub + " + " + this.calculo((sub), null, "#"));
			s = this.calculo((sub), null, "#");
	}
	
	if(s.indexOf('&') >= 0 && s.indexOf('(') < 0 && s.indexOf(')') < 0) {
		System.out.println(s);
		for(int i = 0; i < s.length()&&s.indexOf('&', i) >= 0; i++) {
			p1=s.indexOf('&', i);
			sub=this.dividir(s.substring(p1+1));
		}
		System.out.println(sub + " + " + this.calculo((sub), null, "&"));
			s = this.calculo((sub), null, "&");
	}
	
	if(s.indexOf('(') >= 0) {
		
		for(int i = 0; i <= s.length()&& s.indexOf('(', i) >= 0; i++) {
			p1 = s.indexOf('(', i);
			p2 = s.indexOf(')', i);
		}
		sub = s.substring(0, p1);
		sub2 = s.substring(p1+1,p2);
		sub3 = s.substring(p2+1);
		s = this.dividir(sub+(this.dividir(sub2))+sub3);
	}

	return s;
	}

Es un poco... sucio pero bueno.. si alguien lo necesita que se sienta libre de usarlo!!, y si necesita que le explique algo... que no dude en preguntar!!

Para acabarlo habría que añadir el resto de los metodos de "Math", pero eso ya se lo dejo al que lo necesite xD.

Webness muchas gracias por la respuesta, me dio animos para ponerme con el algoritmo.

EDITO: Al situar el seno ( ¬), el coseno ( #) y la tangente (&) en ciertas posiciones salta Excepción, ahora no tengo tiempo, pero en cuanto lo solucione lo editare de nuevo
EDITO2: Ya está solucionado al parecer, la cosa es que, al buscar en el String el signo "-" para restar, cuando había un número negativo se jodia todo, asi que la solucion "parche" que le he puesto es cambiar el signo "-" de resta, por "r", para que no haya conflictos