在Java中将算术字符串转换为双精度字符串_Java_String_Math_Operators

在Java中将算术字符串转换为双精度字符串

java string math

在Java中将算术字符串转换为双精度字符串,java,string,math,operators,Java,String,Math,Operators,我有一个程序，其中用户输入6个双精度，程序输出每个运算符组合，这些运算符可以作为1024个单独的字符串进入双精度之间。以下是用户输入14、17200、1、5和118时的前两个结果： "14.0+17.0+200.0+1.0+5.0+118.0" "14.0+17.0+200.0+1.0+5.0-118.0" 我想做的是根据运算顺序执行算术。每个double存储为变量a到f，这些变量之间的每个运算符存储为字符a_b到e_f。因此： double a, b, c, d, e, f;

我有一个程序，其中用户输入6个双精度，程序输出每个运算符组合，这些运算符可以作为1024个单独的字符串进入双精度之间。以下是用户输入14、17200、1、5和118时的前两个结果：

"14.0+17.0+200.0+1.0+5.0+118.0"

"14.0+17.0+200.0+1.0+5.0-118.0"

我想做的是根据运算顺序执行算术。每个double存储为变量a到f，这些变量之间的每个运算符存储为字符a_b到e_f。因此：

    double a, b, c, d, e, f;
    char a_b, b_c, c_d, d_e, e_f;

我的第一个想法是这样编写代码：

    public double operateGroup() {
    value = 0;

    switch (a_b) {
    case '+':
        value += a + b;
        break;
    case '-':
        value += a - b;
        break;
    case '*':
        value += a * b;
        break;
    case '/':
        value += a / b;
        break;
    default:
        break;
    }

    switch (b_c) {
    case '+':
        value += c;
        break;
    case '-':
        value += -c;
        break;
    case '*':
        value *= c;
        break;
    case '/':
        value /= c;
        break;
    default:
        break;
    }

    switch (c_d) {
    case '+':
        value += d;
        break;
    case '-':
        value += -d;
        break;
    case '*':
        value *= d;
        break;
    case '/':
        value /= d;
        break;
    default:
        break;
    }

    switch (d_e) {
    case '+':
        value += e;
        break;
    case '-':
        value += -e;
        break;
    case '*':
        value *= e;
        break;
    case '/':
        value /= e;
        break;
    default:
        break;
    }

    switch (e_f) {
    case '+':
        value += f;
        break;
    case '-':
        value += -f;
        break;
    case '*':
        value *= f;
        break;
    case '/':
        value /= f;
        break;
    default:
        break;
    }

    return value;
}

但这不起作用，因为它与（aob）ocod）oe）的作用相同，其中O是任意运算符。有什么建议吗？

我想你应该把它解析成一棵树，然后走到树上进行评估。数字是叶节点，运算符是父节点。

我认为应该将其解析到树中，然后遍历树进行计算。数字是叶节点，运算符是父节点。

因为没有括号，所以可以使用一种简单的方法：

浏览列表一次以处理乘法和除法
当X和Y之间的运算符为
```
*
```
或
```
/
```
时，将
```
X
```
替换为
```
X*Y
```
或
```
X/Y
```
，并移除Y；同时拆下操作员
现在再次浏览列表，这次按顺序处理加法和减法

要实现此方法，请定义两个列表—

Double

s和

N-1

运算符的列表，并按如下方式实现计算：

ArrayList<Double> vals = ...
ArrayList<Integer> ops = ... // 1=+, 2=-, 3=*, 4=/
for (int i = 0 ; i < ops.Count ; i++) {
    int op = ops.get(i);
    if (op == 3 || op == 4) {
        if (op == 3) {
            vals.set(i, vals.get(i) * vals.get(i+1));
        } else {
            vals.set(i, vals.get(i) / vals.get(i+1));
        }
        ops.remove(i);
        vals.remove(i+1);
        i--;
    }
}
double res = vals.get(0);
for (int i = 0 ; i != ops.Count ; i++) {
    if (op == 1) {
        res += vals.get(i);
    } else {
        res -= vals.get(i);
    }
}

ArrayList VAL=。。。
ArrayList ops=…//1=+, 2=-, 3=*, 4=/
for（int i=0；i

由于没有括号，一个简单的方法可以工作：

浏览列表一次以处理乘法和除法
当X和Y之间的运算符为
```
*
```
或
```
/
```
时，将
```
X
```
替换为
```
X*Y
```
或
```
X/Y
```
，并移除Y；同时拆下操作员
现在再次浏览列表，这次按顺序处理加法和减法

要实现此方法，请定义两个列表—

Double

s和

N-1

运算符的列表，并按如下方式实现计算：

ArrayList<Double> vals = ...
ArrayList<Integer> ops = ... // 1=+, 2=-, 3=*, 4=/
for (int i = 0 ; i < ops.Count ; i++) {
    int op = ops.get(i);
    if (op == 3 || op == 4) {
        if (op == 3) {
            vals.set(i, vals.get(i) * vals.get(i+1));
        } else {
            vals.set(i, vals.get(i) / vals.get(i+1));
        }
        ops.remove(i);
        vals.remove(i+1);
        i--;
    }
}
double res = vals.get(0);
for (int i = 0 ; i != ops.Count ; i++) {
    if (op == 1) {
        res += vals.get(i);
    } else {
        res -= vals.get(i);
    }
}

ArrayList VAL=。。。
ArrayList ops=…//1=+, 2=-, 3=*, 4=/
for（int i=0；i

如果需要运算符和操作数的信息，应构建一个（此）

如果您只对结果感兴趣，可以直接计算

字符串

：

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
public class Eval {
    public static void main(String[] args) throws Exception {
        ScriptEngineManager s = new ScriptEngineManager();
        ScriptEngine engine = s.getEngineByName("JavaScript");
        String exp = "14.0+17.0+200.0+1.0+5.0-118.0";
        System.out.println(engine.eval(exp));
    }    
}

输出：

119.0

如果需要运算符和操作数的信息，则应构建一个（此）

如果您只对结果感兴趣，可以直接计算

字符串

：

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
public class Eval {
    public static void main(String[] args) throws Exception {
        ScriptEngineManager s = new ScriptEngineManager();
        ScriptEngine engine = s.getEngineByName("JavaScript");
        String exp = "14.0+17.0+200.0+1.0+5.0-118.0";
        System.out.println(engine.eval(exp));
    }    
}

输出：

119.0

这必须是Java吗？您可以用Python（或其他使用eval的语言）在一行中完成它。比您最初想象的更难：）看到这个问题了吗？这一定是Java吗？你可以用Python（或使用eval的其他语言）在一行中完成。比你最初想象的更难：）看看这个问题，当然，如果安全性很重要，事情会变得复杂得多。是的，当然。但是，正如他之前处理输入一样，在这个特定的案例中，问题似乎被最小化了。当然，如果安全性很重要，事情会变得复杂得多。是的，肯定是这样。然而，在这个特定的案例中，由于他以前处理过输入，问题似乎被最小化了。