Question

我试图通过创建一个简单的计算器来处理涉及括号的算术表达式来巩固对堆栈和运算符的理解。我觉得我有应该工作的代码，但是肯定不能给我正确的输出。

即使我有一个评估每个表达式的方法，当我尝试返回数字堆栈时，它也不会打印出任何被评估的方法，而只会打印出用户输入的所有数字。我也想处理输入不匹配的运算符或缺少括号的问题。

我尝试使用9 * 5之类的简单表达式或（7 * 6）+（9-4）之类的简单表达式来运行代码，无论如何它只会返回最后一个double。

到目前为止，这是我的代码：

主要方法

import java.util.Stack;
import javax.swing.JOptionPane;

public class Calculator {

    // instance variables
    private Stack < Double > nums;
    private Stack < String > ops; 
    String list;

        // constructor
    public Calculator()
    {
        nums = new Stack < Double > ();
        ops = new Stack < String > ();
    }

    // methods

    public static boolean isDouble(String str) {
        try {
            Double.parseDouble(str);
        } catch (NumberFormatException e) {
            return false;
        } catch (NullPointerException e) {
            return false;
        }
        return true;
    }

    public static boolean isValidOp(String str) {
        return (str == "(" || str == ")" || str == "^" || str == "*" || str == "/" || str == "+" || str == "-");
    }

    public int prec(String str) {
        if (str == "(" || str == ")")
            return 4;
        if (str == "^")
            return 3;
        if (str == "*" || str == "/")
            return 2;
        if (str == "+" || str == "-")
            return 1;
        else
            return -1;
    }

    public double applyOperator(double left, String op, double right) {
        if (op == "+") {
            return (left + right);
        }
        if (op == "-") {
            return (left - right);
        }
        if (op == "*") {
            return (left * right);
        }
        if (op == "/") {
            return (left / right);
        }
        if (op == "^") {
            return  Math.pow(left, right);
        } else {
            throw new IllegalArgumentException("Not a valid operator");
        }
    }

    public String evaluate(String str)
    {   
        String [] tokens = str.split(" ");

        for (int i = 0; i < tokens.length; i++)
        {
            if (isDouble(tokens [i]) == true)
            {
                nums.push(Double.parseDouble(tokens [i]));
            }   
            if (tokens [i] == "(")
            {
                ops.push(tokens [i]);
            }
            if (tokens [i] == ")")
            {
                String op1 = ops.pop();
                double num1 = nums.pop();
                double num2 = nums.pop();
                double result = applyOperator(num1,op1,num2);
                nums.add(result);
            }
            if (tokens [i] == "+" || tokens [i] == "-" || tokens [i] == "*" || tokens [i] == "/" || tokens [i] == "^")
            {
                if(ops.isEmpty())
                {
                    ops.push(tokens [i]);
                }
                else if (prec(tokens [i]) > prec(ops.peek()))
                {
                    ops.push(tokens [i]);
                }
                else if (prec(tokens [i]) < prec(ops.peek()) && !ops.isEmpty() && ops.peek() != "(")
                {
                    String ac1 = ops.pop();
                    double res1 = nums.pop();
                    double res2 = nums.pop();
                    double outcome = applyOperator(res1,ac1,res2);
                    nums.add(outcome);
                }   
            }
        }

        while(!ops.isEmpty() && nums.size() > 1)
        {
            String ab = ops.pop();
            double bb = nums.pop();
            double cb = nums.pop();
            double clac = applyOperator(bb,ab,cb);
            nums.add(clac);
        }
        String fix = nums.pop().toString();
        return fix;
    }
}

测试器：

import javax.swing.JOptionPane;

public class AppforCalc {

    public static void main(String [] args)
    {
        Calculator calc = new Calculator();
        String reply = "yes";
        String instructions = "Enter a mathematical expression. Separate everything with spaces";

        while(reply.equalsIgnoreCase("yes"))
        {
            String expression = JOptionPane.showInputDialog(instructions);
            String ans = calc.evaluate(expression);
            reply = JOptionPane.showInputDialog("The solution is " + ans + "Try again?");
        }
    }
}

Answer 1

算法失败的主要原因是由于在尝试检查==相等性时使用了String。

在Java中，==是一个布尔运算符，它对所有操作数的行为相同，并检查操作数的值是否相等。这意味着将按原先的预期检查原语，但是作为对象的字符串将导致比较两个字符串的内存引用，仅当两个字符串实际上是相同的字符串时，才为真。这意味着必须使用equals方法进行字符串相等性检查。

计算器的行为存在更多问题（算法问题），但是在处理字符串相等性检查之后，这些问题将更易于识别和修复。一个必须解决的问题的示例是：

 while(!ops.isEmpty() && nums.size() > 1)
        {
            String ab = ops.pop();
            double bb = nums.pop();
            double cb = nums.pop();
            double clac = applyOperator(bb,ab,cb);
            nums.add(clac);
        }

操作数（bb和cb）是从堆栈中弹出的，因此它们以相反的顺序到达（解析后，cb在{{1}之前被推入堆栈}。这意味着bb是左侧操作数，cb是右侧操作数-> bb对于double clac = applyOperator(cb,ab,bb);方法的所有用法都应进行相同的重构。

另一个问题如下：

applyOperand

进行了内部评估，但是评估的触发是优先级较低的操作数的错误。求值后，应将操作数推入操作堆栈：

        else if (prec(tokens [i]) < prec(ops.peek()) && !ops.isEmpty() && ops.peek() != "(")
        {
            String ac1 = ops.pop();
            double res1 = nums.pop();
            double res2 = nums.pop();
            double outcome = applyOperator(res1,ac1,res2);
            nums.add(outcome);
        }

参考文献：

创建一个“计算器”以评估Java中的算术表达式-代码麻烦

1 个答案: