Bom dia, gostaria de saber como faço para transformar uma equação em um valor float, se alguém puder me ajudar. Fiz assim:
String equacao="(x*x*x)+15";
float x=3;
float valor=Transforma(equacao,x);
public float Transforma(String equacao,float x) {
equacao=equacao.replaceAll("x",""+x); //até aqui fica tudo blz (3*3*3)+15
return Float.parseFloat(equacao);
}
Gostaria de saber como faço para converter o (33 3)+15 em 42, se coloco um valor float=(33 3)+15; dá certo, mais ao converter essa String em float já da errado.
Se alguém puder me ajudar, desde já agradeço.
Cara pelo q eu saiba num da para converter do jeito q vc quer porque a função nao converte os caracteres especias (*,+,-, esses ai), ai no caso ela lança uma execeção.
Acho q vc deveria percorrer a string e fazer um contador para resolver esse exe, tipo minha ideia é essa, num sei se é a melhor mas se quise ajuda fala ae.
Flw
Voce nao tem no Java algo igual ao eval do JavaScript. Voce vai ter que dividir essa String na mão e fazer as contas.
Estou meio que perdido no que fazer então agora.
Qualquer ajuda vai ser bem vindo.
rldpv
Junho 20, 2009, 8:48pm
#5
Acho que o único jeito seria você usar o método charAt() para pegar os caracteres da String separadamente.
É meio complicado.
Amanhã eu posto algo que começei a fazer no trabalho. Mas voce vai ter que terminar o código.
Alias… terminei o código hoje…
O seguinte main faz o que voce queria.
public static void main(String[] args) {
Expression exp = new Expression("(x+x+x)*5");
exp.setVariable("x", 3);
System.out.println(exp.resolve());
}E a classe Expression.
package mark.utils.math;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Pattern;
public class Expression {
private String expression;
private List<Double> numbers = new LinkedList<Double>();
private List<Operator> operators = new LinkedList<Operator>();
public Expression(String exp) {
expression = exp;
}
public static double resolve(String expression) {
return new Expression(expression).resolve();
}
public void setVariable(String name, Object value) {
expression = expression.replaceAll(name, value.toString());
}
public double resolve() {
numbers = new LinkedList<Double>();
operators = new LinkedList<Operator>();
StringBuilder current = new StringBuilder();
if (expression.startsWith("-") || expression.startsWith("+"))
numbers.add(0.0);
for (int i = 0; i < expression.length(); i++) {
String s = expression.substring(i, i + 1);
if (s.equals("(")) {
int opens = 0;
String sub = expression.substring(i);
for (int j = 0; j < sub.length(); j++) {
String ss = sub.substring(j, j + 1);
if (ss.equals("("))
opens++;
if (ss.equals(")"))
opens--;
if (opens == 0) {
String exp = sub.substring(0, j + 1);
String expPure = sub.substring(1, j);
double value = new Expression(expPure).resolve();
expression = expression.replace(exp, Double
.toString(value));
return resolve();
}
}
continue;
}
if (s.matches(operator.pattern())) {
if (s.equals(add.symbol()))
operators.add(add);
else if (s.equals(minus.symbol()))
operators.add(minus);
else if (s.equals(div.symbol()))
operators.add(div);
else
operators.add(times);
continue;
}
current.append(s);
String next = "";
if (expression.length() >= i + 2)
next = expression.substring(i + 1, i + 2);
if (!next.matches(digit.pattern())) {
numbers.add(Double.parseDouble(current.toString()));
current.delete(0, current.length());
}
}
resolveTimesDivs();
double result = 0;
if (numbers.size() == 1)
result = numbers.get(0);
else {
result = operators.get(0).resolve(numbers.get(0), numbers.get(1));
for (int i = 1; i < operators.size(); i++) {
Operator op = operators.get(i);
result = op.resolve(result, numbers.get(i + 1));
}
}
return result;
}
private void resolveTimesDivs() {
for (int i = 0; i < operators.size(); i++) {
Operator op = operators.get(i);
boolean resolve = op.symbol().equals(div.symbol())
|| op.symbol().equals(times.symbol());
if (resolve) {
double d1 = numbers.get(i);
double d2 = numbers.get(i + 1);
double result = op.resolve(d1, d2);
numbers.set(i, result);
numbers.remove(i + 1);
operators.remove(i);
resolveTimesDivs();
break;
}
}
}
private static final Pattern digit = Pattern.compile("[0-9\.]");
private static final Pattern operator = Pattern.compile("[+\-/*]");
private interface Operator {
public double resolve(double first, double second);
public String symbol();
}
private Operator minus = new Operator() {
public double resolve(double first, double second) {
return first - second;
}
public String symbol() {
return "-";
}
};
private Operator add = new Operator() {
public double resolve(double first, double second) {
return first + second;
}
public String symbol() {
return "+";
}
};
private Operator div = new Operator() {
public double resolve(double first, double second) {
return first / second;
}
public String symbol() {
return "/";
}
};
private Operator times = new Operator() {
public double resolve(double first, double second) {
return first * second;
}
public String symbol() {
return "*";
}
};
}
Fiz um post sobre isso no meu blog.
Sei que esporadicamente as pessoas procuram esse assunto então decedi deixar lá para estar mais fácil o acesso a informação.