blocks|key|363297|text|我想无论你怎么做，都会涉及到很多条件陈述。但是，对于示例中的单个操作，您可以将其限制为4个if语句，其内容如下|type|unstyled|depth|inlineStyleRanges|entityRanges|data|363298|String+math+=+"1%2B4";

if+(math.split("%2B").length+==+2)+{
++++//do+calculation
}+else+if+(math.split("-").length+==+2)+{
++++//do+calculation
}+...|code-block|syntax|javascript|363299|当您想要处理"4%2B5*6“这样的多个操作时，它会变得更加复杂。|363300|如果您想要构建一个计算器，那么我最好将计算的每个部分(每个数字或操作符)分别传递，而不是作为一个字符串传递。|363301|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think what ever way you do this it's going to involve a lot of conditional statements. But for single operations like in your examples you could limit it to 4 if statements with something like 

<pre><code>String math = "1+4";

if (math.split("+").length == 2) {
 //do calculation
} else if (math.split("-").length == 2) {
 //do calculation
} ...
</code></pre>

It gets a whole lot more complicated when you want to deal with multiple operations like "4+5*6".

If you are trying to build a calculator then I'd surgest passing each section of the calculation separatly (each number or operator) rather than as a single string.

blocks|key|363378|text|解决这个问题的正确方法是使用雷克萨斯和解析器。您可以自己编写这些代码的简单版本，或者这些页面也有指向Java词汇者和解析器的链接。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|363379|创建递归下降解析器是一个非常好的学习练习。|363380|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lexical_analysis|1|http://en.wikipedia.org/wiki/Parser^0|E|4|0|J|3|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

The correct way to solve this is with a <a href="http://en.wikipedia.org/wiki/Lexical_analysis" rel="noreferrer">lexer</a> and a <a href="http://en.wikipedia.org/wiki/Parser" rel="noreferrer">parser</a>. You can write simple versions of these yourself, or those pages also have links to Java lexers and parsers.

Creating a recursive descent parser is a really good learning exercise.

blocks|key|1915997|text|看来杰普应该做好这份工作|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1915998|entityMap|0|LINK|mutability|MUTABLE|url|http://sourceforge.net/projects/jep/^0|2|2|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

It seems like <a href="http://sourceforge.net/projects/jep/" rel="noreferrer">JEP</a> should do the job

blocks|key|1560059|text|使用JDK1.6，您可以使用内置的Javascript引擎。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1560060|import+javax.script.ScriptEngineManager;
import+javax.script.ScriptEngine;
import+javax.script.ScriptException;

public+class+Test+{
++public+static+void+main(String[]+args)+throws+ScriptException+{
++++ScriptEngineManager+mgr+=+new+ScriptEngineManager();
++++ScriptEngine+engine+=+mgr.getEngineByName("JavaScript");
++++String+foo+=+"40%2B2";
++++System.out.println(engine.eval(foo));
++++}+
}|code-block|syntax|javascript|1560061|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

With JDK1.6, you can use the built-in Javascript engine.

<pre><code>import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class Test {
 public static void main(String[] args) throws ScriptException {
 ScriptEngineManager mgr = new ScriptEngineManager();
 ScriptEngine engine = mgr.getEngineByName("JavaScript");
 String foo = "40+2";
 System.out.println(engine.eval(foo));
 } 
}
</code></pre>

blocks|key|363436|text|import+java.util.*;

public+class+check+{+
+++int+ans;
+++String+str="7+%2B+5";
+++StringTokenizer+st=new+StringTokenizer(str);

+++int+v1=Integer.parseInt(st.nextToken());
+++String+op=st.nextToken();
+++int+v2=Integer.parseInt(st.nextToken());

+++if(op.equals("%2B"))+{+ans=+v1+%2B+v2;+}
+++if(op.equals("-"))+{+ans=+v1+-+v2;+}
+++//.........
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|363437|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import java.util.*;

public class check { 
 int ans;
 String str="7 + 5";
 StringTokenizer st=new StringTokenizer(str);

 int v1=Integer.parseInt(st.nextToken());
 String op=st.nextToken();
 int v2=Integer.parseInt(st.nextToken());

 if(op.equals("+")) { ans= v1 + v2; }
 if(op.equals("-")) { ans= v1 - v2; }
 //.........
}
</code></pre>

blocks|key|363463|text|这篇文章讨论了各种方法。以下是文章中提到的两种关键方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|363464|来自Apache的JEXL|363465|允许包含对java对象的引用的脚本。|363466|//+Create+or+retrieve+a+JexlEngine
JexlEngine+jexl+=+new+JexlEngine();
//+Create+an+expression+object
String+jexlExp+=+"foo.innerFoo.bar()";
Expression+e+=+jexl.createExpression(+jexlExp+);
+
//+Create+a+context+and+add+data
JexlContext+jctx+=+new+MapContext();
jctx.set("foo",+new+Foo()+);
+
//+Now+evaluate+the+expression,+getting+the+result
Object+o+=+e.evaluate(jctx);|code-block|syntax|javascript|363467|使用嵌入在JDK中的javascript引擎：|363468|private+static+void+jsEvalWithVariable()
{
++++List<String>+namesList+=+new+ArrayList<String>();
++++namesList.add("Jill");
++++namesList.add("Bob");
++++namesList.add("Laureen");
++++namesList.add("Ed");
+
++++ScriptEngineManager+mgr+=+new+ScriptEngineManager();
++++ScriptEngine+jsEngine+=+mgr.getEngineByName("JavaScript");
+
++++jsEngine.put("namesListKey",+namesList);
++++System.out.println("Executing+in+script+environment...");
++++try
++++{
++++++jsEngine.eval("var+x;"+%2B
++++++++++++++++++++"var+names+=+namesListKey.toArray();"+%2B
++++++++++++++++++++"for(x+in+names)+{"+%2B
++++++++++++++++++++"++println(names[x]);"+%2B
++++++++++++++++++++"}"+%2B
++++++++++++++++++++"namesListKey.add(\"Dana\");");
++++}
++++catch+(ScriptException+ex)
++++{
++++++++ex.printStackTrace();
++++}
}|363469|entityMap|0|LINK|mutability|MUTABLE|url|http://www.beyondlinux.com/2011/08/07/3-method-to-evaluate-expressions/|1|http://commons.apache.org/proper/commons-jexl/^0|0|4|0|0|0|D|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|19|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1B|8|@]|9|@]|C|$K|L]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]]]

<a href="http://www.beyondlinux.com/2011/08/07/3-method-to-evaluate-expressions/" rel="noreferrer">This article</a> discusses various approaches. Here are the 2 key approaches mentioned in the article:
<h3><a href="http://commons.apache.org/proper/commons-jexl/" rel="noreferrer">JEXL from Apache</a></h3>
Allows for scripts that include references to java objects.
<pre><code>// Create or retrieve a JexlEngine
JexlEngine jexl = new JexlEngine();
// Create an expression object
String jexlExp = &quot;foo.innerFoo.bar()&quot;;
Expression e = jexl.createExpression( jexlExp );
 
// Create a context and add data
JexlContext jctx = new MapContext();
jctx.set(&quot;foo&quot;, new Foo() );
 
// Now evaluate the expression, getting the result
Object o = e.evaluate(jctx);
</code></pre>
<h3>Use the javascript engine embedded in the JDK:</h3>
<pre><code>private static void jsEvalWithVariable()
{
 List&lt;String&gt; namesList = new ArrayList&lt;String&gt;();
 namesList.add(&quot;Jill&quot;);
 namesList.add(&quot;Bob&quot;);
 namesList.add(&quot;Laureen&quot;);
 namesList.add(&quot;Ed&quot;);
 
 ScriptEngineManager mgr = new ScriptEngineManager();
 ScriptEngine jsEngine = mgr.getEngineByName(&quot;JavaScript&quot;);
 
 jsEngine.put(&quot;namesListKey&quot;, namesList);
 System.out.println(&quot;Executing in script environment...&quot;);
 try
 {
 jsEngine.eval(&quot;var x;&quot; +
 &quot;var names = namesListKey.toArray();&quot; +
 &quot;for(x in names) {&quot; +
 &quot; println(names[x]);&quot; +
 &quot;}&quot; +
 &quot;namesListKey.add(\&quot;Dana\&quot;);&quot;);
 }
 catch (ScriptException ex)
 {
 ex.printStackTrace();
 }
}
</code></pre>

blocks|key|1560099|text|您还可以尝试使用BeanShell解释器：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1560100|Interpreter+interpreter+=+new+Interpreter();
interpreter.eval("result+=+(7%2B21*6)/(32-27)");
System.out.println(interpreter.get("result"));|code-block|syntax|javascript|1560101|entityMap|0|LINK|mutability|MUTABLE|url|http://www.beanshell.org/^0|8|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can also try the <a href="http://www.beanshell.org" rel="noreferrer">BeanShell</a> interpreter:

<pre><code>Interpreter interpreter = new Interpreter();
interpreter.eval("result = (7+21*6)/(32-27)");
System.out.println(interpreter.get("result"));
</code></pre>

blocks|key|1560133|text|像这样的事怎么样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1560134|String+st+=+"10%2B3";
int+result;
for(int+i=0;i<st.length();i%2B%2B)
{
++if(st.charAt(i)=='%2B')
++{
++++result=Integer.parseInt(st.substring(0,+i))%2BInteger.parseInt(st.substring(i%2B1,+st.length()));
++++System.out.print(result);
++}+++++++++
}|code-block|syntax|javascript|1560135|并相应地对其他数学算子做类似的事情。|1560136|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

How about something like this:

<pre><code>String st = "10+3";
int result;
for(int i=0;i&lt;st.length();i++)
{
 if(st.charAt(i)=='+')
 {
 result=Integer.parseInt(st.substring(0, i))+Integer.parseInt(st.substring(i+1, st.length()));
 System.out.print(result);
 } 
}
</code></pre>

and do the similar thing for every other mathematical operator accordingly ..

blocks|key|1560148|text|这里是GitHub上另一个名为EvalEx的开源库。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1560149|与JavaScript引擎不同，这个库只专注于计算数学表达式。此外，该库是可扩展的，并支持使用布尔运算符和括号。|1560150|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/uklimaschewski/EvalEx^0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

<a href="https://github.com/uklimaschewski/EvalEx" rel="noreferrer">HERE</a> is another open source library on GitHub named EvalEx.

Unlike the JavaScript engine this library is focused in evaluating mathematical expressions only. Moreover, the library is extensible and supports use of boolean operators as well as parentheses.

blocks|key|363591|text|另一种方法是使用Spring表达式语言或SpEL，它在计算数学表达式的同时做得更多，因此可能有点过火了。您不必使用Spring框架来使用这个表达式库，因为它是独立的。从SpEL的文档中复制示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|363592|ExpressionParser+parser+=+new+SpelExpressionParser();
int+two+=+parser.parseExpression("1+%2B+1").getValue(Integer.class);+//+2+
double+twentyFour+=+parser.parseExpression("2.0+*+3e0+*+4").getValue(Double.class);+//24.0|code-block|syntax|javascript|363593|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions^0|8|G|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Another way is to use the <a href="https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions" rel="nofollow noreferrer">Spring Expression Language or SpEL</a> which does a whole lot more along with evaluating mathematical expressions, therefore maybe slightly overkill. You do not have to be using Spring framework to use this expression library as it is stand-alone. Copying examples from SpEL's documentation:
<pre><code>ExpressionParser parser = new SpelExpressionParser();
int two = parser.parseExpression(&quot;1 + 1&quot;).getValue(Integer.class); // 2 
double twentyFour = parser.parseExpression(&quot;2.0 * 3e0 * 4&quot;).getValue(Double.class); //24.0
</code></pre>

blocks|key|363623|text|这是另一个有趣的替代https://github.com/Shy-Ta/expression-evaluator-demo|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|363624|使用非常简单，可以完成任务，例如：|363625|++ExpressionsEvaluator+evalExpr+=+ExpressionsFactory.create("2%2B3*4-6/2");++
++assertEquals(BigDecimal.valueOf(11),+evalExpr.eval());+|code-block|syntax|javascript|363626|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/Shy-Ta/expression-evaluator-demo^0|A|1F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

This is another interesting alternative 
<a href="https://github.com/Shy-Ta/expression-evaluator-demo" rel="nofollow">https://github.com/Shy-Ta/expression-evaluator-demo</a>

The usage is very simple and gets the job done, for example:

<pre><code> ExpressionsEvaluator evalExpr = ExpressionsFactory.create("2+3*4-6/2"); 
 assertEquals(BigDecimal.valueOf(11), evalExpr.eval()); 
</code></pre>

blocks|key|363645|text|可以使用贾克斯特拉的调车场算法将infix符号中的任何表达式字符串转换为后缀符号。然后，算法的结果可以作为后缀算法的输入，并返回表达式的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|363646|我写了一篇关于它的文章，这里，使用java实现。|363647|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Shunting-yard_algorithm|1|https://en.wikipedia.org/wiki/Reverse_Polish_notation|2|http://emmanueljohn.me/2015/07/05/shunting-yard-algorithm/^0|4|B|0|1H|4|1|0|C|C|2|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|F|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]]]

It is possible to convert any expression string in infix notation to a postfix notation using <a href="https://en.wikipedia.org/wiki/Shunting-yard_algorithm" rel="nofollow">Djikstra's shunting-yard algorithm</a>. The result of the algorithm can then serve as input to the <a href="https://en.wikipedia.org/wiki/Reverse_Polish_notation" rel="nofollow">postfix algorithm</a> with returns the result of the expression.

I wrote an article about it <a href="http://emmanueljohn.me/2015/07/05/shunting-yard-algorithm/" rel="nofollow">here, with an implementation in java</a>

blocks|key|1916277|text|如果我们要实现它，我们可以使用以下算法:--|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916278|尽管仍有标记可读，
1.1获取下一个令牌。1.2如果令牌是：
1.2.1数字:将其推到值堆栈上。
1.2.2变量:获取其值，并推到值堆栈上。
1.2.3左括号:将其推到运算符堆栈上。
1.2.4右括号：
1虽然运算符堆栈顶部的东西不是左括号，但1从运算符堆栈中弹出运算符。2弹出值堆栈两次，得到两个操作数。3以正确的顺序将运算符应用于操作数。4将结果推到值堆栈上。2从运算符堆栈中弹出左括号，并丢弃它。
1.2.5操作员(称为thisOp)：
1虽然操作符堆栈不是空的，而且操作符堆栈上的顶部事物具有与thisOp相同或更高的优先级，但是1从操作符堆栈中弹出操作符。2弹出值堆栈两次，得到两个操作数。3以正确的顺序将运算符应用于操作数。4将结果推到值堆栈上。2将thisOp推到操作符堆栈上。|ordered-list-item|1916279|虽然运算符堆栈不是空的，但1从运算符堆栈中弹出运算符。2弹出值堆栈两次，得到两个操作数。3以正确的顺序将运算符应用于操作数。4将结果推到值堆栈上。|1916280|此时操作符堆栈应该是空的，值堆栈应该只有一个值，这是最后的结果。|1916281|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|M|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|N|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|O|8|@]|9|@]|A|$]]]|J|$]]

if we are going to implement it then we can can use the below algorithm :--

<ol>
<li>While there are still tokens to be read in,

1.1 Get the next token.
1.2 If the token is:

1.2.1 A number: push it onto the value stack.

1.2.2 A variable: get its value, and push onto the value stack.

1.2.3 A left parenthesis: push it onto the operator stack.

1.2.4 A right parenthesis:

<pre><code> 1 While the thing on top of the operator stack is not a 
 left parenthesis,
 1 Pop the operator from the operator stack.
 2 Pop the value stack twice, getting two operands.
 3 Apply the operator to the operands, in the correct order.
 4 Push the result onto the value stack.
 2 Pop the left parenthesis from the operator stack, and discard it.
</code></pre>

1.2.5 An operator (call it thisOp):

<pre><code> 1 While the operator stack is not empty, and the top thing on the
 operator stack has the same or greater precedence as thisOp,
 1 Pop the operator from the operator stack.
 2 Pop the value stack twice, getting two operands.
 3 Apply the operator to the operands, in the correct order.
 4 Push the result onto the value stack.
 2 Push thisOp onto the operator stack.
</code></pre></li>
<li>While the operator stack is not empty,
1 Pop the operator from the operator stack.
2 Pop the value stack twice, getting two operands.
3 Apply the operator to the operands, in the correct order.
4 Push the result onto the value stack.</li>
<li>At this point the operator stack should be empty, and the value
stack should have only one value in it, which is the final result.</li>
</ol>

blocks|key|363669|text|现在回答已经太晚了，但是我遇到了同样的情况，用java来计算表达式，它可能会帮助某人|type|unstyled|depth|inlineStyleRanges|entityRanges|data|363670|MVEL对表达式进行运行时计算，我们可以在String中编写java代码，以便在此中对其进行评估。|offset|length|style|CODE|363671|++++String+expressionStr+=+"x%2By";
++++Map<String,+Object>+vars+=+new+HashMap<String,+Object>();
++++vars.put("x",+10);
++++vars.put("y",+20);
++++ExecutableStatement+statement+=+(ExecutableStatement)+MVEL.compileExpression(expressionStr);
++++Object+result+=+MVEL.executeExpression(statement,+vars);|code-block|syntax|javascript|363672|entityMap^0|0|0|4|L|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

It's too late to answer but I came across same situation to evaluate expression in java, it might help someone

<code>MVEL</code> does runtime evaluation of expressions, we can write a java code in <code>String</code> to get it evaluated in this.

<pre><code> String expressionStr = "x+y";
 Map&lt;String, Object&gt; vars = new HashMap&lt;String, Object&gt;();
 vars.put("x", 10);
 vars.put("y", 20);
 ExecutableStatement statement = (ExecutableStatement) MVEL.compileExpression(expressionStr);
 Object result = MVEL.executeExpression(statement, vars);
</code></pre>

blocks|key|1560378|text|你可以看看Symja框架|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1560379|ExprEvaluator+util+=+new+ExprEvaluator();+
IExpr+result+=+util.evaluate("10-40");
System.out.println(result.toString());+//+->+"-30"+|code-block|syntax|javascript|1560380|请注意，可以对更复杂的表达式进行评估：|1560381|//+D(...)+gives+the+derivative+of+the+function+Sin(x)*Cos(x)
IAST+function+=+D(Times(Sin(x),+Cos(x)),+x);
IExpr+result+=+util.evaluate(function);
//+print:+Cos(x)%5E2-Sin(x)%5E2|1560382|entityMap|0|LINK|mutability|MUTABLE|url|https://bitbucket.org/axelclk/symja_android_library/wiki/Home^0|5|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You might have a look at the <a href="https://bitbucket.org/axelclk/symja_android_library/wiki/Home" rel="nofollow">Symja framework</a>:

<pre><code>ExprEvaluator util = new ExprEvaluator(); 
IExpr result = util.evaluate("10-40");
System.out.println(result.toString()); // -&gt; "-30" 
</code></pre>

Take note that definitively more complex expressions can be evaluated:

<pre><code>// D(...) gives the derivative of the function Sin(x)*Cos(x)
IAST function = D(Times(Sin(x), Cos(x)), x);
IExpr result = util.evaluate(function);
// print: Cos(x)^2-Sin(x)^2
</code></pre>

blocks|key|363769|text|在我的大学项目中，我正在寻找一个解析器/评估器，它既支持基本公式，也支持更复杂的方程(特别是迭代运算符)。我为JAVA和.NET找到了一个很好的开源库，叫做mXparser。我会给一些例子，使一些感觉的语法，进一步的说明，请访问项目网站(特别是教程部分)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|363770|https://mathparser.org/|offset|length|363771|https://mathparser.org/mxparser-tutorial/|363772|https://mathparser.org/api/|363773|也很少有例子|363774|1-单呋喃|363775|Expression+e+=+new+Expression("(+2+%2B+3/4+%2B+sin(pi)+)/2");
double+v+=+e.calculate()|code-block|syntax|javascript|363776|2-用户定义的参数和常量|363777|Argument+x+=+new+Argument("x+=+10");
Constant+a+=+new+Constant("a+=+pi%5E2");
Expression+e+=+new+Expression("cos(a*x)",+x,+a);
double+v+=+e.calculate()|363778|3-用户定义的函数|363779|Function+f+=+new+Function("f(x,+y,+z)+=+sin(x)+%2B+cos(y*z)");
Expression+e+=+new+Expression("f(3,2,5)",+f);
double+v+=+e.calculate()|363780|4-迭代|363781|Expression+e+=+new+Expression("sum(+i,+1,+100,+sin(i)+)");
double+v+=+e.calculate()|363782|最近发现的-如果您想尝试语法(并查看高级用例)，您可以下载由标量+计算器+应用程序驱动的mXparser。|363783|entityMap|0|LINK|mutability|MUTABLE|url|1|2|3|https://scalarmath.org/|4|https://play.google.com/store/apps/details?id=org.mathparser.scalar.lite|5|https://play.google.com/store/apps/details?id=org.mathparser.scalar.pro^0|0|0|N|0|0|0|15|1|0|0|R|2|0|0|0|0|0|0|0|0|0|0|U|2|3|X|3|4|11|4|5|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1M|8|@]|9|@$D|1N|E|1O|1|1P]]|A|$]]|$1|F|3|G|5|6|7|1Q|8|@]|9|@$D|1R|E|1S|1|1T]]|A|$]]|$1|H|3|I|5|6|7|1U|8|@]|9|@$D|1V|E|1W|1|1X]]|A|$]]|$1|J|3|K|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|20|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|21|8|@]|9|@]|A|$]]|$1|U|3|V|5|P|7|22|8|@]|9|@]|A|$Q|R]]|$1|W|3|X|5|6|7|23|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|24|8|@]|9|@]|A|$Q|R]]|$1|10|3|11|5|6|7|25|8|@]|9|@]|A|$]]|$1|12|3|13|5|P|7|26|8|@]|9|@]|A|$Q|R]]|$1|14|3|15|5|6|7|27|8|@]|9|@$D|28|E|29|1|2A]|$D|2B|E|2C|1|2D]|$D|2E|E|2F|1|2G]]|A|$]]|$1|16|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]]|17|$18|$5|19|1A|1B|A|$1C|C]]|1D|$5|19|1A|1B|A|$1C|G]]|1E|$5|19|1A|1B|A|$1C|I]]|1F|$5|19|1A|1B|A|$1C|1G]]|1H|$5|19|1A|1B|A|$1C|1I]]|1J|$5|19|1A|1B|A|$1C|1K]]]]

For my university project, I was looking for a parser / evaluator supporting both basic formulas and more complicated equations (especially iterated operators). I found very nice open source library for JAVA and .NET called mXparser. I will give a few examples to make some feeling on the syntax, for further instructions please visit project website (especially tutorial section).
<a href="https://mathparser.org/" rel="noreferrer">https://mathparser.org/</a>
<a href="https://mathparser.org/mxparser-tutorial/" rel="noreferrer">https://mathparser.org/mxparser-tutorial/</a>
<a href="https://mathparser.org/api/" rel="noreferrer">https://mathparser.org/api/</a>
And few examples
1 - Simple furmula
<pre><code>Expression e = new Expression(&quot;( 2 + 3/4 + sin(pi) )/2&quot;);
double v = e.calculate()
</code></pre>
2 - User defined arguments and constants
<pre><code>Argument x = new Argument(&quot;x = 10&quot;);
Constant a = new Constant(&quot;a = pi^2&quot;);
Expression e = new Expression(&quot;cos(a*x)&quot;, x, a);
double v = e.calculate()
</code></pre>
3 - User defined functions
<pre><code>Function f = new Function(&quot;f(x, y, z) = sin(x) + cos(y*z)&quot;);
Expression e = new Expression(&quot;f(3,2,5)&quot;, f);
double v = e.calculate()
</code></pre>
4 - Iteration
<pre><code>Expression e = new Expression(&quot;sum( i, 1, 100, sin(i) )&quot;);
double v = e.calculate()
</code></pre>
Found recently - in case you would like to try the syntax (and see the advanced use case) you can download the <a href="https://scalarmath.org" rel="noreferrer">Scalar</a> <a href="https://play.google.com/store/apps/details?id=org.mathparser.scalar.lite" rel="noreferrer">Calculator</a> <a href="https://play.google.com/store/apps/details?id=org.mathparser.scalar.pro" rel="noreferrer">app</a> that is powered by mXparser.

blocks|key|363839|text|还有一个选择：https://github.com/stefanhaustein/expressionparser|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|363840|我这样做是为了有一个简单但灵活的选择，既可以做到这一点，也可以做到：|363841|即时处理(Calculator.java，SetDemo.java)|unordered-list-item|363842|构建和处理解析树(TreeBuilder.java)|363843|上面链接的TreeBuilder是执行符号派生的CAS演示包的一部分。还有一个基本解释器示例，我已经开始使用它构建一个TypeScript解释器。|363844|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/stefanhaustein/expressionparser|1|https://github.com/stefanhaustein/expressionparser/blob/master/src/main/java/org/kobjects/expressionparser/demo/calculator/Calculator.java|2|https://github.com/stefanhaustein/expressionparser/blob/master/src/main/java/org/kobjects/expressionparser/demo/sets/SetDemo.java|3|https://github.com/stefanhaustein/expressionparser/blob/master/src/main/java/org/kobjects/expressionparser/demo/cas/TreeBuilder.java|4|https://github.com/stefanhaustein/expressionparser/tree/master/src/main/java/org/kobjects/expressionparser/demo/cas|5|https://github.com/stefanhaustein/expressionparser/tree/master/src/main/java/org/kobjects/expressionparser/demo/basic|6|https://github.com/stefanhaustein/typo^0|7|1E|0|0|0|5|F|1|L|C|2|0|9|G|3|0|O|6|4|13|5|5|1N|D|6|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]|$A|1F|B|1G|1|1H]]|C|$]]|$1|I|3|J|5|H|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|K|3|L|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]|$A|1Q|B|1R|1|1S]|$A|1T|B|1U|1|1V]]|C|$]]|$1|M|3|-4|5|6|7|1W|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]|Y|$5|P|Q|R|C|$S|Z]]|10|$5|P|Q|R|C|$S|11]]|12|$5|P|Q|R|C|$S|13]]|14|$5|P|Q|R|C|$S|15]]]]

Yet another option: <a href="https://github.com/stefanhaustein/expressionparser" rel="nofollow">https://github.com/stefanhaustein/expressionparser</a>

I have implemented this to have a simple but flexible option to permit both:

<ul>
<li>Immediate processing (<a href="https://github.com/stefanhaustein/expressionparser/blob/master/src/main/java/org/kobjects/expressionparser/demo/calculator/Calculator.java" rel="nofollow">Calculator.java</a>, <a href="https://github.com/stefanhaustein/expressionparser/blob/master/src/main/java/org/kobjects/expressionparser/demo/sets/SetDemo.java" rel="nofollow">SetDemo.java</a>)</li>
<li>Building and processing a parse tree (<a href="https://github.com/stefanhaustein/expressionparser/blob/master/src/main/java/org/kobjects/expressionparser/demo/cas/TreeBuilder.java" rel="nofollow">TreeBuilder.java</a>)</li>
</ul>

The TreeBuilder linked above is part of a <a href="https://github.com/stefanhaustein/expressionparser/tree/master/src/main/java/org/kobjects/expressionparser/demo/cas" rel="nofollow">CAS demo package</a> that does symbolic derivation. There is also a <a href="https://github.com/stefanhaustein/expressionparser/tree/master/src/main/java/org/kobjects/expressionparser/demo/basic" rel="nofollow">BASIC interpreter</a> example and I have started to build a <a href="https://github.com/stefanhaustein/typo" rel="nofollow">TypeScript interpreter</a> using it.

blocks|key|1916466|text|如果Java应用程序已经访问了数据库，则可以轻松地计算表达式，而无需使用任何其他JAR。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916467|有些数据库要求您使用虚拟表(例如，Oracle的“双”表)，而其他数据库则允许您在不从任何表中“选择”的情况下计算表达式。|1916468|例如，在Server或Sqlite中|1916469|select+(((12.10+%2B12.0))/+233.0)+amount|code-block|syntax|javascript|1916470|在甲骨文中|1916471|select+(((12.10+%2B12.0))/+233.0)+amount+from+dual;|1916472|使用DB的优点是可以同时计算多个表达式。此外，大多数DB将允许您使用高度复杂的表达式，并且还将有一些额外的函数可以在必要时调用。|1916473|但是，如果需要单独评估许多单个表达式，特别是当DB位于网络服务器上时，性能可能会受到影响。|1916474|下面通过使用Sqlite数据库在一定程度上解决了性能问题.|1916475|以下是Java中的一个完整的示例|1916476|Class.+forName("org.sqlite.JDBC");
Connection+conn+=+DriverManager.getConnection("jdbc:sqlite::memory:");
Statement+stat+=+conn.createStatement();
ResultSet+rs+=+stat.executeQuery(+"select+(1%2B10)/20.0+amount");
rs.next();
System.out.println(rs.getBigDecimal(1));
stat.close();
conn.close();|1916477|当然，您可以扩展上面的代码以同时处理多个计算。|1916478|ResultSet+rs+=+stat.executeQuery(+"select+(1%2B10)/20.0+amount,+(1%2B100)/20.0+amount2");|1916479|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1E|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1F|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|1G|8|@]|9|@]|A|$I|J]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

You can evaluate expressions easily if your Java application already accesses a database, without using any other JARs.

Some databases require you to use a dummy table (eg, Oracle's "dual" table) and others will allow you to evaluate expressions without "selecting" from any table.

For example, in Sql Server or Sqlite

<pre><code>select (((12.10 +12.0))/ 233.0) amount
</code></pre>

and in Oracle

<pre><code>select (((12.10 +12.0))/ 233.0) amount from dual;
</code></pre>

The advantage of using a DB is that you can evaluate many expressions at the same time. Also most DB's will allow you to use highly complex expressions and will also have a number of extra functions that can be called as necessary. 

However performance may suffer if many single expressions need to be evaluated individually, particularly when the DB is located on a network server.

The following addresses the performance problem to some extent, by using a Sqlite in-memory database. 

Here's a full working example in Java

<pre><code>Class. forName("org.sqlite.JDBC");
Connection conn = DriverManager.getConnection("jdbc:sqlite::memory:");
Statement stat = conn.createStatement();
ResultSet rs = stat.executeQuery( "select (1+10)/20.0 amount");
rs.next();
System.out.println(rs.getBigDecimal(1));
stat.close();
conn.close();
</code></pre>

Of course you could extend the above code to handle multiple calculations at the same time.

<pre><code>ResultSet rs = stat.executeQuery( "select (1+10)/20.0 amount, (1+100)/20.0 amount2");
</code></pre>

blocks|key|363919|text|package+ExpressionCalculator.expressioncalculator;

import+java.text.DecimalFormat;
import+java.util.Scanner;

public+class+ExpressionCalculator+{

private+static+String+addSpaces(String+exp){

++++//Add+space+padding+to+operands.
++++//https://regex101.com/r/sJ9gM7/73
++++exp+=+exp.replaceAll("(?<=[0-9()])[\\/]",+"+/+");
++++exp+=+exp.replaceAll("(?<=[0-9()])[\\%5E]",+"+%5E+");
++++exp+=+exp.replaceAll("(?<=[0-9()])[\\*]",+"+*+");
++++exp+=+exp.replaceAll("(?<=[0-9()])[%2B]",+"+%2B+");+
++++exp+=+exp.replaceAll("(?<=[0-9()])[-]",+"+-+");

++++//Keep+replacing+double+spaces+with+single+spaces+until+your+string+is+properly+formatted
++++/*while(exp.indexOf("++")+!=+-1){
++++++++exp+=+exp.replace("++",+"+");
+++++}*/
++++exp+=+exp.replaceAll("+{2,}",+"+");

+++++++return+exp;
}

public+static+Double+evaluate(String+expr){

++++DecimalFormat+df+=+new+DecimalFormat("#.####");

++++//Format+the+expression+properly+before+performing+operations
++++String+expression+=+addSpaces(expr);

++++try+{
++++++++//We+will+evaluate+using+rule+BDMAS,+i.e.+brackets,+division,+power,+multiplication,+addition+and
++++++++//subtraction+will+be+processed+in+following+order
++++++++int+indexClose+=+expression.indexOf(")");
++++++++int+indexOpen+=+-1;
++++++++if+(indexClose+!=+-1)+{
++++++++++++String+substring+=+expression.substring(0,+indexClose);
++++++++++++indexOpen+=+substring.lastIndexOf("(");
++++++++++++substring+=+substring.substring(indexOpen+%2B+1).trim();
++++++++++++if(indexOpen+!=+-1+&&+indexClose+!=+-1)+{
++++++++++++++++Double+result+=+evaluate(substring);
++++++++++++++++expression+=+expression.substring(0,+indexOpen).trim()+%2B+"+"+%2B+result+%2B+"+"+%2B+expression.substring(indexClose+%2B+1).trim();
++++++++++++++++return+evaluate(expression.trim());
++++++++++++}
++++++++}

++++++++String+operation+=+"";
++++++++if(expression.indexOf("+/+")+!=+-1){
++++++++++++operation+=+"/";
++++++++}else+if(expression.indexOf("+%5E+")+!=+-1){
++++++++++++operation+=+"%5E";
++++++++}+else+if(expression.indexOf("+*+")+!=+-1){
++++++++++++operation+=+"*";
++++++++}+else+if(expression.indexOf("+%2B+")+!=+-1){
++++++++++++operation+=+"%2B";
++++++++}+else+if(expression.indexOf("+-+")+!=+-1){+//Avoid+negative+numbers
++++++++++++operation+=+"-";
++++++++}+else{
++++++++++++return+Double.parseDouble(expression);
++++++++}

++++++++int+index+=+expression.indexOf(operation);
++++++++if(index+!=+-1){
++++++++++++indexOpen+=+expression.lastIndexOf("+",+index+-+2);
++++++++++++indexOpen+=+(indexOpen+==+-1)?0:indexOpen;
++++++++++++indexClose+=+expression.indexOf("+",+index+%2B+2);
++++++++++++indexClose+=+(indexClose+==+-1)?expression.length():indexClose;
++++++++++++if(indexOpen+!=+-1+&&+indexClose+!=+-1)+{
++++++++++++++++Double+lhs+=+Double.parseDouble(expression.substring(indexOpen,+index));
++++++++++++++++Double+rhs+=+Double.parseDouble(expression.substring(index+%2B+2,+indexClose));
++++++++++++++++Double+result+=+null;
++++++++++++++++switch+(operation){
++++++++++++++++++++case+"/":
++++++++++++++++++++++++//Prevent+divide+by+0+exception.
++++++++++++++++++++++++if(rhs+==+0){
++++++++++++++++++++++++++++return+null;
++++++++++++++++++++++++}
++++++++++++++++++++++++result+=+lhs+/+rhs;
++++++++++++++++++++++++break;
++++++++++++++++++++case+"%5E":
++++++++++++++++++++++++result+=+Math.pow(lhs,+rhs);
++++++++++++++++++++++++break;
++++++++++++++++++++case+"*":
++++++++++++++++++++++++result+=+lhs+*+rhs;
++++++++++++++++++++++++break;
++++++++++++++++++++case+"-":
++++++++++++++++++++++++result+=+lhs+-+rhs;
++++++++++++++++++++++++break;
++++++++++++++++++++case+"%2B":
++++++++++++++++++++++++result+=+lhs+%2B+rhs;
++++++++++++++++++++++++break;
++++++++++++++++++++default:
++++++++++++++++++++++++break;
++++++++++++++++}
++++++++++++++++if(indexClose+==+expression.length()){
++++++++++++++++++++expression+=+expression.substring(0,+indexOpen)+%2B+"+"+%2B+result+%2B+"+"+%2B+expression.substring(indexClose);
++++++++++++++++}else{
++++++++++++++++++++expression+=+expression.substring(0,+indexOpen)+%2B+"+"+%2B+result+%2B+"+"+%2B+expression.substring(indexClose+%2B+1);
++++++++++++++++}
++++++++++++++++return+Double.valueOf(df.format(evaluate(expression.trim())));
++++++++++++}
++++++++}
++++}catch(Exception+exp){
++++++++exp.printStackTrace();
++++}
++++return+0.0;
}

public+static+void+main(String+args[]){

++++Scanner+scanner+=+new+Scanner(System.in);
++++System.out.print("Enter+an+Mathematical+Expression+to+Evaluate:+");
++++String+input+=+scanner.nextLine();
++++System.out.println(evaluate(input));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|363920|}|unstyled|363921|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>package ExpressionCalculator.expressioncalculator;

import java.text.DecimalFormat;
import java.util.Scanner;

public class ExpressionCalculator {

private static String addSpaces(String exp){

 //Add space padding to operands.
 //https://regex101.com/r/sJ9gM7/73
 exp = exp.replaceAll("(?&lt;=[0-9()])[\\/]", " / ");
 exp = exp.replaceAll("(?&lt;=[0-9()])[\\^]", " ^ ");
 exp = exp.replaceAll("(?&lt;=[0-9()])[\\*]", " * ");
 exp = exp.replaceAll("(?&lt;=[0-9()])[+]", " + "); 
 exp = exp.replaceAll("(?&lt;=[0-9()])[-]", " - ");

 //Keep replacing double spaces with single spaces until your string is properly formatted
 /*while(exp.indexOf(" ") != -1){
 exp = exp.replace(" ", " ");
 }*/
 exp = exp.replaceAll(" {2,}", " ");

 return exp;
}

public static Double evaluate(String expr){

 DecimalFormat df = new DecimalFormat("#.####");

 //Format the expression properly before performing operations
 String expression = addSpaces(expr);

 try {
 //We will evaluate using rule BDMAS, i.e. brackets, division, power, multiplication, addition and
 //subtraction will be processed in following order
 int indexClose = expression.indexOf(")");
 int indexOpen = -1;
 if (indexClose != -1) {
 String substring = expression.substring(0, indexClose);
 indexOpen = substring.lastIndexOf("(");
 substring = substring.substring(indexOpen + 1).trim();
 if(indexOpen != -1 &amp;&amp; indexClose != -1) {
 Double result = evaluate(substring);
 expression = expression.substring(0, indexOpen).trim() + " " + result + " " + expression.substring(indexClose + 1).trim();
 return evaluate(expression.trim());
 }
 }

 String operation = "";
 if(expression.indexOf(" / ") != -1){
 operation = "/";
 }else if(expression.indexOf(" ^ ") != -1){
 operation = "^";
 } else if(expression.indexOf(" * ") != -1){
 operation = "*";
 } else if(expression.indexOf(" + ") != -1){
 operation = "+";
 } else if(expression.indexOf(" - ") != -1){ //Avoid negative numbers
 operation = "-";
 } else{
 return Double.parseDouble(expression);
 }

 int index = expression.indexOf(operation);
 if(index != -1){
 indexOpen = expression.lastIndexOf(" ", index - 2);
 indexOpen = (indexOpen == -1)?0:indexOpen;
 indexClose = expression.indexOf(" ", index + 2);
 indexClose = (indexClose == -1)?expression.length():indexClose;
 if(indexOpen != -1 &amp;&amp; indexClose != -1) {
 Double lhs = Double.parseDouble(expression.substring(indexOpen, index));
 Double rhs = Double.parseDouble(expression.substring(index + 2, indexClose));
 Double result = null;
 switch (operation){
 case "/":
 //Prevent divide by 0 exception.
 if(rhs == 0){
 return null;
 }
 result = lhs / rhs;
 break;
 case "^":
 result = Math.pow(lhs, rhs);
 break;
 case "*":
 result = lhs * rhs;
 break;
 case "-":
 result = lhs - rhs;
 break;
 case "+":
 result = lhs + rhs;
 break;
 default:
 break;
 }
 if(indexClose == expression.length()){
 expression = expression.substring(0, indexOpen) + " " + result + " " + expression.substring(indexClose);
 }else{
 expression = expression.substring(0, indexOpen) + " " + result + " " + expression.substring(indexClose + 1);
 }
 return Double.valueOf(df.format(evaluate(expression.trim())));
 }
 }
 }catch(Exception exp){
 exp.printStackTrace();
 }
 return 0.0;
}

public static void main(String args[]){

 Scanner scanner = new Scanner(System.in);
 System.out.print("Enter an Mathematical Expression to Evaluate: ");
 String input = scanner.nextLine();
 System.out.println(evaluate(input));
}
</code></pre>

}

blocks|key|1916496|text|使用JDK1.6的Javascript引擎和代码注入处理来尝试下面的示例代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916497|import+javax.script.ScriptEngine;
import+javax.script.ScriptEngineManager;

public+class+EvalUtil+{
private+static+ScriptEngine+engine+=+new+ScriptEngineManager().getEngineByName("JavaScript");
public+static+void+main(String[]+args)+{
++++try+{
++++++++System.out.println((new+EvalUtil()).eval("(((5%2B5)/2)+>+5)+%7C%7C+5+>3+"));
++++++++System.out.println((new+EvalUtil()).eval("(((5%2B5)/2)+>+5)+%7C%7C+true"));
++++}+catch+(Exception+e)+{
++++++++e.printStackTrace();
++++}
}
public+Object+eval(String+input)+throws+Exception{
++++try+{
++++++++if(input.matches(".*[a-zA-Z;~`#$_{}\\[\\]:\\\\;\"',\\.\\?]%2B.*"))+{
++++++++++++throw+new+Exception("Invalid+expression+:+"+%2B+input+);
++++++++}
++++++++return+engine.eval(input);
++++}+catch+(Exception+e)+{
++++++++e.printStackTrace();
++++++++throw+e;
++++}
+}
}|code-block|syntax|javascript|1916498|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try the following sample code using JDK1.6's Javascript engine with code injection handling.

<pre><code>import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class EvalUtil {
private static ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");
public static void main(String[] args) {
 try {
 System.out.println((new EvalUtil()).eval("(((5+5)/2) &gt; 5) || 5 &gt;3 "));
 System.out.println((new EvalUtil()).eval("(((5+5)/2) &gt; 5) || true"));
 } catch (Exception e) {
 e.printStackTrace();
 }
}
public Object eval(String input) throws Exception{
 try {
 if(input.matches(".*[a-zA-Z;~`#$_{}\\[\\]:\\\\;\"',\\.\\?]+.*")) {
 throw new Exception("Invalid expression : " + input );
 }
 return engine.eval(input);
 } catch (Exception e) {
 e.printStackTrace();
 throw e;
 }
 }
}
</code></pre>

blocks|key|1916561|text|这实际上是对@Boann的回答的补充。它有一个小错误，导致"-2+%5E+2“给出-4.0的错误结果。这方面的问题是在his中求指数的点。只要将指数移动到parseTerm()块，就可以了。请看下面的内容，它是@Boann的回答稍微修改过的。修改意见在评论中。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1916562|public+static+double+eval(final+String+str)+{
++++return+new+Object()+{
++++++++int+pos+=+-1,+ch;

++++++++void+nextChar()+{
++++++++++++ch+=+(%2B%2Bpos+<+str.length())+?+str.charAt(pos)+:+-1;
++++++++}

++++++++boolean+eat(int+charToEat)+{
++++++++++++while+(ch+==+'+')+nextChar();
++++++++++++if+(ch+==+charToEat)+{
++++++++++++++++nextChar();
++++++++++++++++return+true;
++++++++++++}
++++++++++++return+false;
++++++++}

++++++++double+parse()+{
++++++++++++nextChar();
++++++++++++double+x+=+parseExpression();
++++++++++++if+(pos+<+str.length())+throw+new+RuntimeException("Unexpected:+"+%2B+(char)ch);
++++++++++++return+x;
++++++++}

++++++++//+Grammar:
++++++++//+expression+=+term+%7C+expression+`%2B`+term+%7C+expression+`-`+term
++++++++//+term+=+factor+%7C+term+`*`+factor+%7C+term+`/`+factor
++++++++//+factor+=+`%2B`+factor+%7C+`-`+factor+%7C+`(`+expression+`)`
++++++++//++++++++%7C+number+%7C+functionName+factor+%7C+factor+`%5E`+factor

++++++++double+parseExpression()+{
++++++++++++double+x+=+parseTerm();
++++++++++++for+(;;)+{
++++++++++++++++if++++++(eat('%2B'))+x+%2B=+parseTerm();+//+addition
++++++++++++++++else+if+(eat('-'))+x+-=+parseTerm();+//+subtraction
++++++++++++++++else+return+x;
++++++++++++}
++++++++}

++++++++double+parseTerm()+{
++++++++++++double+x+=+parseFactor();
++++++++++++for+(;;)+{
++++++++++++++++if++++++(eat('*'))+x+*=+parseFactor();+//+multiplication
++++++++++++++++else+if+(eat('/'))+x+/=+parseFactor();+//+division
++++++++++++++++else+if+(eat('%5E'))+x+=+Math.pow(x,+parseFactor());+//exponentiation+->+Moved+in+to+here.+So+the+problem+is+fixed
++++++++++++++++else+return+x;
++++++++++++}
++++++++}

++++++++double+parseFactor()+{
++++++++++++if+(eat('%2B'))+return+parseFactor();+//+unary+plus
++++++++++++if+(eat('-'))+return+-parseFactor();+//+unary+minus

++++++++++++double+x;
++++++++++++int+startPos+=+this.pos;
++++++++++++if+(eat('('))+{+//+parentheses
++++++++++++++++x+=+parseExpression();
++++++++++++++++eat(')');
++++++++++++}+else+if+((ch+>=+'0'+&&+ch+<=+'9')+%7C%7C+ch+==+'.')+{+//+numbers
++++++++++++++++while+((ch+>=+'0'+&&+ch+<=+'9')+%7C%7C+ch+==+'.')+nextChar();
++++++++++++++++x+=+Double.parseDouble(str.substring(startPos,+this.pos));
++++++++++++}+else+if+(ch+>=+'a'+&&+ch+<=+'z')+{+//+functions
++++++++++++++++while+(ch+>=+'a'+&&+ch+<=+'z')+nextChar();
++++++++++++++++String+func+=+str.substring(startPos,+this.pos);
++++++++++++++++x+=+parseFactor();
++++++++++++++++if+(func.equals("sqrt"))+x+=+Math.sqrt(x);
++++++++++++++++else+if+(func.equals("sin"))+x+=+Math.sin(Math.toRadians(x));
++++++++++++++++else+if+(func.equals("cos"))+x+=+Math.cos(Math.toRadians(x));
++++++++++++++++else+if+(func.equals("tan"))+x+=+Math.tan(Math.toRadians(x));
++++++++++++++++else+throw+new+RuntimeException("Unknown+function:+"+%2B+func);
++++++++++++}+else+{
++++++++++++++++throw+new+RuntimeException("Unexpected:+"+%2B+(char)ch);
++++++++++++}

++++++++++++//if+(eat('%5E'))+x+=+Math.pow(x,+parseFactor());+//+exponentiation+->+This+is+causing+a+bit+of+problem

++++++++++++return+x;
++++++++}
++++}.parse();
}|code-block|syntax|javascript|1916563|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/26227947/3126973^0|2V|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

This is actually complementing the answer given by @Boann. It has a slight bug which causes "-2 ^ 2" to give an erroneous result of -4.0. The problem for that is the point at which the exponentiation is evaluated in his. Just move the exponentiation to the block of parseTerm(), and you'll be all fine. Have a look at the below, which is <a href="https://stackoverflow.com/a/26227947/3126973">@Boann's answer</a> slightly modified. Modification is in the comments.

<pre><code>public static double eval(final String str) {
 return new Object() {
 int pos = -1, ch;

 void nextChar() {
 ch = (++pos &lt; str.length()) ? str.charAt(pos) : -1;
 }

 boolean eat(int charToEat) {
 while (ch == ' ') nextChar();
 if (ch == charToEat) {
 nextChar();
 return true;
 }
 return false;
 }

 double parse() {
 nextChar();
 double x = parseExpression();
 if (pos &lt; str.length()) throw new RuntimeException("Unexpected: " + (char)ch);
 return x;
 }

 // Grammar:
 // expression = term | expression `+` term | expression `-` term
 // term = factor | term `*` factor | term `/` factor
 // factor = `+` factor | `-` factor | `(` expression `)`
 // | number | functionName factor | factor `^` factor

 double parseExpression() {
 double x = parseTerm();
 for (;;) {
 if (eat('+')) x += parseTerm(); // addition
 else if (eat('-')) x -= parseTerm(); // subtraction
 else return x;
 }
 }

 double parseTerm() {
 double x = parseFactor();
 for (;;) {
 if (eat('*')) x *= parseFactor(); // multiplication
 else if (eat('/')) x /= parseFactor(); // division
 else if (eat('^')) x = Math.pow(x, parseFactor()); //exponentiation -&gt; Moved in to here. So the problem is fixed
 else return x;
 }
 }

 double parseFactor() {
 if (eat('+')) return parseFactor(); // unary plus
 if (eat('-')) return -parseFactor(); // unary minus

 double x;
 int startPos = this.pos;
 if (eat('(')) { // parentheses
 x = parseExpression();
 eat(')');
 } else if ((ch &gt;= '0' &amp;&amp; ch &lt;= '9') || ch == '.') { // numbers
 while ((ch &gt;= '0' &amp;&amp; ch &lt;= '9') || ch == '.') nextChar();
 x = Double.parseDouble(str.substring(startPos, this.pos));
 } else if (ch &gt;= 'a' &amp;&amp; ch &lt;= 'z') { // functions
 while (ch &gt;= 'a' &amp;&amp; ch &lt;= 'z') nextChar();
 String func = str.substring(startPos, this.pos);
 x = parseFactor();
 if (func.equals("sqrt")) x = Math.sqrt(x);
 else if (func.equals("sin")) x = Math.sin(Math.toRadians(x));
 else if (func.equals("cos")) x = Math.cos(Math.toRadians(x));
 else if (func.equals("tan")) x = Math.tan(Math.toRadians(x));
 else throw new RuntimeException("Unknown function: " + func);
 } else {
 throw new RuntimeException("Unexpected: " + (char)ch);
 }

 //if (eat('^')) x = Math.pow(x, parseFactor()); // exponentiation -&gt; This is causing a bit of problem

 return x;
 }
 }.parse();
}
</code></pre>

blocks|key|1916581|text|可以计算数学表达式的Java类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916582|package+test;

public+class+Calculator+{

++++public+static+Double+calculate(String+expression){
++++++++if+(expression+==+null+%7C%7C+expression.length()+==+0)+{
++++++++++++return+null;
++++++++}
++++++++return+calc(expression.replace("+",+""));
++++}
++++public+static+Double+calc(String+expression)+{
++++++++String[]+containerArr+=+new+String[]{expression};
++++++++double+leftVal+=+getNextOperand(containerArr);
++++++++expression+=+containerArr[0];
++++++++if+(expression.length()+==+0)+{
++++++++++++return+leftVal;
++++++++}
++++++++char+operator+=+expression.charAt(0);
++++++++expression+=+expression.substring(1);

++++++++while+(operator+==+'*'+%7C%7C+operator+==+'/')+{
++++++++++++containerArr[0]+=+expression;
++++++++++++double+rightVal+=+getNextOperand(containerArr);
++++++++++++expression+=+containerArr[0];
++++++++++++if+(operator+==+'*')+{
++++++++++++++++leftVal+=+leftVal+*+rightVal;
++++++++++++}+else+{
++++++++++++++++leftVal+=+leftVal+/+rightVal;
++++++++++++}
++++++++++++if+(expression.length()+>+0)+{
++++++++++++++++operator+=+expression.charAt(0);
++++++++++++++++expression+=+expression.substring(1);
++++++++++++}+else+{
++++++++++++++++return+leftVal;
++++++++++++}
++++++++}
++++++++if+(operator+==+'%2B')+{
++++++++++++return+leftVal+%2B+calc(expression);
++++++++}+else+{
++++++++++++return+leftVal+-+calc(expression);
++++++++}

++++}
++++
++++private+static+double+getNextOperand(String[]+exp){
++++++++double+res;
++++++++if+(exp[0].startsWith("("))+{
++++++++++++int+open+=+1;
++++++++++++int+i+=+1;
++++++++++++while+(open+!=+0)+{
++++++++++++++++if+(exp[0].charAt(i)+==+'(')+{
++++++++++++++++++++open%2B%2B;
++++++++++++++++}+else+if+(exp[0].charAt(i)+==+')')+{
++++++++++++++++++++open--;
++++++++++++++++}
++++++++++++++++i%2B%2B;
++++++++++++}
++++++++++++res+=+calc(exp[0].substring(1,+i+-+1));
++++++++++++exp[0]+=+exp[0].substring(i);
++++++++}+else+{
++++++++++++int+i+=+1;
++++++++++++if+(exp[0].charAt(0)+==+'-')+{
++++++++++++++++i%2B%2B;
++++++++++++}
++++++++++++while+(exp[0].length()+>+i+&&+isNumber((int)+exp[0].charAt(i)))+{
++++++++++++++++i%2B%2B;
++++++++++++}
++++++++++++res+=+Double.parseDouble(exp[0].substring(0,+i));
++++++++++++exp[0]+=+exp[0].substring(i);
++++++++}
++++++++return+res;
++++}


++++private+static+boolean+isNumber(int+c)+{
++++++++int+zero+=+(int)+'0';
++++++++int+nine+=+(int)+'9';
++++++++return+(c+>=+zero+&&+c+<=+nine)+%7C%7C+c+=='.';
++++}

++++public+static+void+main(String[]+args)+{
++++++++System.out.println(calculate("((((+-6+))))+*+9+*+-1"));
++++++++System.out.println(calc("(-5.2%2B-5*-5*((5/4%2B2)))"));

++++}

}|code-block|syntax|javascript|1916583|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A Java class that can evaluate mathematical expressions:
<pre><code>package test;

public class Calculator {

 public static Double calculate(String expression){
 if (expression == null || expression.length() == 0) {
 return null;
 }
 return calc(expression.replace(&quot; &quot;, &quot;&quot;));
 }
 public static Double calc(String expression) {
 String[] containerArr = new String[]{expression};
 double leftVal = getNextOperand(containerArr);
 expression = containerArr[0];
 if (expression.length() == 0) {
 return leftVal;
 }
 char operator = expression.charAt(0);
 expression = expression.substring(1);

 while (operator == '*' || operator == '/') {
 containerArr[0] = expression;
 double rightVal = getNextOperand(containerArr);
 expression = containerArr[0];
 if (operator == '*') {
 leftVal = leftVal * rightVal;
 } else {
 leftVal = leftVal / rightVal;
 }
 if (expression.length() &gt; 0) {
 operator = expression.charAt(0);
 expression = expression.substring(1);
 } else {
 return leftVal;
 }
 }
 if (operator == '+') {
 return leftVal + calc(expression);
 } else {
 return leftVal - calc(expression);
 }

 }
 
 private static double getNextOperand(String[] exp){
 double res;
 if (exp[0].startsWith(&quot;(&quot;)) {
 int open = 1;
 int i = 1;
 while (open != 0) {
 if (exp[0].charAt(i) == '(') {
 open++;
 } else if (exp[0].charAt(i) == ')') {
 open--;
 }
 i++;
 }
 res = calc(exp[0].substring(1, i - 1));
 exp[0] = exp[0].substring(i);
 } else {
 int i = 1;
 if (exp[0].charAt(0) == '-') {
 i++;
 }
 while (exp[0].length() &gt; i &amp;&amp; isNumber((int) exp[0].charAt(i))) {
 i++;
 }
 res = Double.parseDouble(exp[0].substring(0, i));
 exp[0] = exp[0].substring(i);
 }
 return res;
 }


 private static boolean isNumber(int c) {
 int zero = (int) '0';
 int nine = (int) '9';
 return (c &gt;= zero &amp;&amp; c &lt;= nine) || c =='.';
 }

 public static void main(String[] args) {
 System.out.println(calculate(&quot;(((( -6 )))) * 9 * -1&quot;));
 System.out.println(calc(&quot;(-5.2+-5*-5*((5/4+2)))&quot;));

 }

}
</code></pre>

blocks|key|1916614|text|外部库(如犀牛或NASHORN+)可用于运行javascript。而javascript可以在不解析字符串的情况下计算简单公式。如果代码编写得很好，性能也不会受到影响。下面是犀牛的一个例子-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1916615|public+class+RhinoApp+{
++++private+String+simpleAdd+=+"(12%2B13%2B2-2)*2%2B(12%2B13%2B2-2)*2";

public+void+runJavaScript()+{
++++Context+jsCx+=+Context.enter();
++++Context.getCurrentContext().setOptimizationLevel(-1);
++++ScriptableObject+scope+=+jsCx.initStandardObjects();
++++Object+result+=+jsCx.evaluateString(scope,+simpleAdd+,+"formula",+0,+null);
++++Context.exit();
++++System.out.println(result);
}|code-block|syntax|javascript|1916616|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

External library like RHINO or NASHORN can be used to run javascript. And javascript can evaluate simple formula without parcing the string. No performance impact as well if code is written well.
Below is an example with RHINO - 

<pre><code>public class RhinoApp {
 private String simpleAdd = "(12+13+2-2)*2+(12+13+2-2)*2";

public void runJavaScript() {
 Context jsCx = Context.enter();
 Context.getCurrentContext().setOptimizationLevel(-1);
 ScriptableObject scope = jsCx.initStandardObjects();
 Object result = jsCx.evaluateString(scope, simpleAdd , "formula", 0, null);
 Context.exit();
 System.out.println(result);
}
</code></pre>

blocks|key|364007|text|import+javax.script.ScriptEngine;
import+javax.script.ScriptEngineManager;
import+javax.script.ScriptException;

public+class+test2+{
++++public+static+void+main(String[]+args)+throws+ScriptException+{
++++++++String+s+=+"10%2B2";
++++++++ScriptEngineManager+mn+=+new+ScriptEngineManager();
++++++++ScriptEngine+en+=+mn.getEngineByName("js");
++++++++Object+result+=+en.eval(s);
++++++++System.out.println(result);
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|364008|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class test2 {
 public static void main(String[] args) throws ScriptException {
 String s = &quot;10+2&quot;;
 ScriptEngineManager mn = new ScriptEngineManager();
 ScriptEngine en = mn.getEngineByName(&quot;js&quot;);
 Object result = en.eval(s);
 System.out.println(result);
 }
}
</code></pre>

blocks|key|364025|text|我已经使用了迭代解析和分流场算法，我非常喜欢开发表达式计算器，您可以在这里找到所有的代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|364026|https://github.com/nagaraj200788/JavaExpressionEvaluator|offset|length|364027|有73个测试用例，甚至为Bigintegers，大小数点工作|364028|支持所有关系式、算术表达式以及两者的组合。甚至支持三值运算符。|364029|添加增强以支持有符号数字(如-100%2B89+)--它是深入研究的，有关详细信息，请查看TokenReader.isUnaryOperator()方法，我在上面的链接中更新了代码|364030|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1K|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|C]]]]

I have done using iterative parsing and shunting Yard algorithm and i have really enjoyed developing the expression evaluator ,you can find all the code here
<a href="https://github.com/nagaraj200788/JavaExpressionEvaluator" rel="nofollow noreferrer">https://github.com/nagaraj200788/JavaExpressionEvaluator</a>
Has 73 test cases and even works for Bigintegers,Bigdecimals
supports all relational, arithmetic expression and also combination of both .
even supports ternary operator .
Added enhancement to support signed numbers like -100+89 it was intresting, for details check TokenReader.isUnaryOperator() method and i have updated code in above Link

I'm trying to write a Java routine to evaluate math expressions from <code>String</code> values like:
<ol>
<li><code>&quot;5+3&quot;</code></li>
<li><code>&quot;10-40&quot;</code></li>
<li><code>&quot;(1+10)*3&quot;</code></li>
</ol>
I want to avoid a lot of if-then-else statements.
How can I do this?

How to evaluate a math expression given in string form?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我试图编写一个Java例程来计算来自String值的数学表达式，例如："5+3""10-40""(1+10)*3"我想避免很多如果-然后-否则的陈述。我该怎么做？

问如何计算以字符串形式给出的数学表达式？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何计算以字符串形式给出的数学表达式？EN