Java 前缀表达式以同时计算多个表达式 私有类InputListener实现ActionListener { 已执行的公共无效操作（操作事件e） { 堆栈操作数堆栈=新堆栈（）； 堆栈运算符堆栈=新堆栈（）； 字符串输入=inputTextField.getText（）； StringTokenizer strToken=新的StringTokenizer（输入“”，false）； while（strToken.hasMoreTokens（）） { 字符串i=strToken.nextToken（）； 整数操作数； 字符算子； 尝试 { 操作数=整数.parseInt（i）； 操作数堆栈。推送（操作数）； } 捕获（NumberFormatException nfe） { 运算符=i.charAt（0）； 操作员定位推送（操作员）； } } int result=sum（操作数堆栈、运算符堆栈）； resultTextField.setText（Integer.toString（result））； }

我的前缀表达式代码一次只计算一个表达式（即+3 1）。我希望它计算一个用户输入表达式中的多个表达式（即。*+16 4+3 1）。我如何编辑提供的代码以使其计算多个表达式？感谢您的帮助。

要使您的程序执行更多操作，您可以使用循环继续对

操作数堆栈进行操作，并将上一个结果的结果推送到堆栈中。我将
println
语句留在堆栈中，以便您可以查看其内容我还修改了你的方法，使它可以放在一个独立的
main
方法中

你应该研究一下调车场算法，它的实现非常有趣，这有点像你在这里所做的

然后从堆栈中弹出并将其传递给方法。将更改堆栈的代码保存在一个位置

private static int operate(Integer a, Integer b, char operator) {
    switch(operator) {
        case '-':
            return b - a;
        case '+':
            return a + b;
        default:
            throw new IllegalStateException("Unknown operator '"+operator+"'");
    }
}

方法
sum
在做什么？@isnot2bad sum方法计算操作数的和或乘积。我在sum方法中使用if…else if语句进行计算。例如：if（operator='+'）{operan1=operanstack.pop（）；operan2=operanstack.pop（）；result=operan2+operan1；}。我如何编辑代码以使其同时计算多个表达式？谢谢。我现在正在实现您的代码，但不确定您给我的最后一行代码放在哪里：operateStack.push（operate（operate（operate.pop（），operatorStack.pop（），operatorStack.pop（））；。我在哪里实现它？@Jeremy它将取代
operateStack.push（operate（Operator（operatorStack，operatorStack））；
在while循环中。我还需要使用resultTextField.setText（）；语句将结果存储在GUI中，但您已将其删除。我现在如何使用它？@Jeremy将其添加回…与以前相同的方式。我将其添加回，并将“result”替换为“operatorStack.peek（）），但现在还有另一个问题；它不能使用多个运算符正确计算。前缀表达式*+16 4+3 1应等于80，但它等于128。如何更正此问题？
public static void main(String[] args) {
    Stack<Integer> operandStack = new Stack<Integer>();
    Stack<Character> operatorStack = new Stack<Character>();

    String input = "12 + 13 - 4";

    StringTokenizer strToken = new StringTokenizer(input, " ", false);

    while (strToken.hasMoreTokens()) {
        String i = strToken.nextToken();
        int operand;
        char operator;

        try {
            operand = Integer.parseInt(i);
            operandStack.push(operand);
        } catch (NumberFormatException nfe) {
            operator = i.charAt(0);
            operatorStack.push(operator);
        }
    }

    // loop until there is only 1 item left in the operandStack, this 1 item left is the result
    while(operandStack.size() > 1) {
        // some debugging println
        System.out.println("Operate\n\tbefore");
        System.out.println("\t"+operandStack);
        System.out.println("\t"+operatorStack);

        // perform the operations on the stack and push the result back onto the operandStack
        operandStack.push(operate(operandStack, operatorStack));

        System.out.println("\tafter");
        System.out.println("\t"+operandStack);
        System.out.println("\t"+operatorStack);
    }

    System.out.println("Result is: " + operandStack.peek());
}

/**
 * Performs math operations and returns the result. Pops 2 items off the operandStack and 1 off the operator stack. 
 * @param operandStack
 * @param operatorStack
 * @return
 */
private static int operate(Stack<Integer> operandStack, Stack<Character> operatorStack) {
    char op = operatorStack.pop();
    Integer a = operandStack.pop();
    Integer b = operandStack.pop();
    switch(op) {
        case '-':
            return b - a;
        case '+':
            return a + b;
        default:
            throw new IllegalStateException("Unknown operator '"+op+"'");
    }
}

private static int operate(Integer a, Integer b, char operator) {
    switch(operator) {
        case '-':
            return b - a;
        case '+':
            return a + b;
        default:
            throw new IllegalStateException("Unknown operator '"+operator+"'");
    }
}

operandStack.push(operate(operandStack.pop(), operandStack.pop(), operatorStack.pop()));