Java中BODMAS的算法计算

我已经为Bodmas编写了这段代码，但是在这段代码中出现了一些错误。如果我做3-5+9，结果将是3.04.0

它只是开始连接，尽管它适用于所有其他操作，如*、/和-，请帮助

public static String calculation(BODMASCalculation bodmas, String result) {
    while (bodmas.hasMatch()) {
        double value, leftOfOperator = bodmas.getLeft();
        char op = bodmas.getOperator();
        double rightOfOprator = bodmas.getRight();

        switch (op) {
        case '/':
            if(rightOfOprator == 0) //Divide by 0 generates Infinity
                value = 0;
            else
                value = leftOfOperator / rightOfOprator;
            break;
        case '*':
            value = leftOfOperator * rightOfOprator;
            break;
        case '+':
            value = leftOfOperator + rightOfOprator;
            break;
        case '-':
            value = leftOfOperator - rightOfOprator;
            break;
        default:
            throw new IllegalArgumentException("Unknown operator.");
        }           
        result = result.substring(0, bodmas.getStart()) + value + result.substring(bodmas.getEnd());
        bodmas = new BODMASCalculation(result);
    }
    return result;
}

另一个功能是：-

public boolean getMatchFor(String text, char operator) {
    String regex = "(-?[\\d\\.]+)(\\x)(-?[\\d\\.]+)";
    java.util.regex.Matcher matcher = java.util.regex.Pattern.compile(regex.replace('x', operator)).matcher(text);
    if (matcher.find()) {
        this.leftOfOperator = Double.parseDouble(matcher.group(1));
        this.op = matcher.group(2).charAt(0);
        this.rightOfOprator = Double.parseDouble(matcher.group(3));
        this.start = matcher.start();
        this.end = matcher.end();
        return true;
    }
    return false;
}

我有一个解决方案，添加

String sss = null;
        if(op == '+' && !Str.isBlank(result.substring(0, bodmas.getStart())) && value >= 0)
            sss = "+";
        else
            sss = "";
        result = result.substring(0, bodmas.getStart()) + sss + value   + result.substring(bodmas.getEnd());

但我不想这样做，我希望这对所有的操作符都有效。

import java.util.Stack；
import java.util.Stack;

public class EvaluateString
{
    public static int evaluate(String expression)
    {
        char[] tokens = expression.toCharArray();

         // Stack for numbers: 'values'
        Stack<Integer> values = new Stack<Integer>();

        // Stack for Operators: 'ops'
        Stack<Character> ops = new Stack<Character>();

        for (int i = 0; i < tokens.length; i++)
        {
             // Current token is a whitespace, skip it
            if (tokens[i] == ' ')
                continue;

            // Current token is a number, push it to stack for numbers
            if (tokens[i] >= '0' && tokens[i] <= '9')
            {
                StringBuffer sbuf = new StringBuffer();
                // There may be more than one digits in number
                while (i < tokens.length && tokens[i] >= '0' && tokens[i] <= '9')
                    sbuf.append(tokens[i++]);
                values.push(Integer.parseInt(sbuf.toString()));
            }

            // Current token is an opening brace, push it to 'ops'
            else if (tokens[i] == '(')
                ops.push(tokens[i]);

            // Closing brace encountered, solve entire brace
            else if (tokens[i] == ')')
            {
                while (ops.peek() != '(')
                  values.push(applyOp(ops.pop(), values.pop(), values.pop()));
                ops.pop();
            }

            // Current token is an operator.
            else if (tokens[i] == '+' || tokens[i] == '-' ||
                     tokens[i] == '*' || tokens[i] == '/')
            {
                // While top of 'ops' has same or greater precedence to current
                // token, which is an operator. Apply operator on top of 'ops'
                // to top two elements in values stack
                while (!ops.empty() && hasPrecedence(tokens[i], ops.peek()))
                  values.push(applyOp(ops.pop(), values.pop(), values.pop()));

                // Push current token to 'ops'.
                ops.push(tokens[i]);
            }
        }

        // Entire expression has been parsed at this point, apply remaining
        // ops to remaining values
        while (!ops.empty())
            values.push(applyOp(ops.pop(), values.pop(), values.pop()));

        // Top of 'values' contains result, return it
        return values.pop();
    }

    // Returns true if 'op2' has higher or same precedence as 'op1',
    // otherwise returns false.
    public static boolean hasPrecedence(char op1, char op2)
    {
        if (op2 == '(' || op2 == ')')
            return false;
        if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-'))
            return false;
        else
            return true;
    }

    // A utility method to apply an operator 'op' on operands 'a' 
    // and 'b'. Return the result.
    public static int applyOp(char op, int b, int a)
    {
        switch (op)
        {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            if (b == 0)
                throw new
                UnsupportedOperationException("Cannot divide by zero");
            return a / b;
        }
        return 0;
    }

    // Driver method to test above methods
    public static void main(String[] args)
    {
        System.out.println(EvaluateString.evaluate("10 + 2 * 6"));
        System.out.println(EvaluateString.evaluate("100 * 2 + 12"));
        System.out.println(EvaluateString.evaluate("100 * ( 2 + 12 )"));
        System.out.println(EvaluateString.evaluate("100 * ( 2 + 12 ) / 14"));
    }
}

公共类测试环
{
公共静态整型求值（字符串表达式）
{
char[]tokens=expression.toCharArray（）；
//数字堆栈：“值”
堆栈值=新堆栈（）；
//操作员堆栈：“ops”
堆栈操作=新堆栈（）；
for（int i=0；i如果（令牌[i]>='0'&&tokens[i]='0'&&tokens[i]Java脚本API允许您将参数从Java应用程序传递到脚本引擎，反之亦然

您可以使用Javax ScriptEngine将值从应用程序传递到脚本

使用它的
eval（）
方法，你可以给它一个字符串形式的数学表达式，它将为你做数学运算…（也处理BODMAS）

例如：

输出：70

如果IDE不建议，请包括以下导入：

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

请检查此处的文档

我希望它能有所帮助。
“BODMAS”不是一个很实用的规则。尤其是加法和减法具有相同的优先级，从左到右计算1-2+3-4+5=（（1-2）+3）-4）+5

该规则适用于嵌套循环

环路

替换所有
（
编号
）
-->编号
替换所有编号“[*/]”编号-->编号操作编号
替换所有编号“[+-]”编号-->编号操作编号
直到什么都没有被取代

这确保了3-4/26+5-2->3-26+5-2->3-12+5-3->-9+5-3->-4
您尝试过使用调试器吗？如果是，您从使用调试器中学到了什么？是的，我可以修复，但它不会是通用的。所以我需要一个通用的调试器。修复什么？您所说的“通用”是什么意思？适用于所有算术运算的代码。不要将代码放在注释中。它几乎不可读。还请为您的答案添加一些解释。仅代码不能解释任何内容，被认为是低质量的。请查看和您的答案。这是Dijkstra调车场算法。您当然应该这么说，您应该已经解释了这是如何解决问题的，以及为什么会解决这个问题。此外，这不适用于负输入的情况，例如（“-4*-4”）
import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;