Java中栈实现后缀表达式求值：字符与数值转换的常见陷阱与解决方案

// ... (其他代码)

public static float postFixEvaluation(String expr){
    Stack<Float> stack = new Stack<>();
    int index = 0;

    while(index < expr.length()){
        char token = expr.charAt(index);
        boolean x = isOperand(token);

        if(x == true){     // operand
            float operandIn = (float)token; // 错误：这里将字符'3'转换为其ASCII值51.0
            stack.push(operandIn);
        }
        // ... (其他代码)
    }
    // ...
}

import java.util.Stack;

public class PostFixEvaluate {

    /**
     * 执行基本的算术运算。
     * 注意：操作数顺序为 operand_2 运算符 operand_1。
     *
     * @param operand_1 第一个从栈中弹出的操作数（右操作数）。
     * @param operator 运算符。
     * @param operand_2 第二个从栈中弹出的操作数（左操作数）。
     * @return 运算结果。
     * @throws ArithmeticException 如果发生除零错误。
     * @throws IllegalArgumentException 如果遇到无效运算符。
     */
    public static float calculate(Float operand_1, char operator, Float operand_2) {
        switch (operator) {
            case '+':
                return operand_2 + operand_1;
            case '-':
                return operand_2 - operand_1;
            case '*':
                return operand_2 * operand_1;
            case '/':
                if (operand_1 == 0) {
                    throw new ArithmeticException("Division by zero error.");
                }
                return operand_2 / operand_1;
            default:
                throw new IllegalArgumentException("Invalid operator: " + operator);
        }
    }

    /**
     * 判断一个字符是否为数字操作数。
     *
     * @param c 待判断的字符。
     * @return 如果是数字字符 ('0'-'9') 则返回 true，否则返回 false。
     */
    public static boolean isOperand(char c) {
        return c >= '0' && c <= '9';
    }

    /**
     * 对后缀表达式进行求值。
     *
     * @param expr 后缀表达式字符串。
     * @return 表达式的计算结果。
     * @throws IllegalArgumentException 如果表达式格式无效或操作数不足。
     */
    public static float postFixEvaluation(String expr) {
        Stack<Float> stack = new Stack<>();
        int index = 0;

        while (index < expr.length()) {
            char token = expr.charAt(index);

            if (isOperand(token)) { // 操作数
                // 核心修正：将字符数字转换为其数值
                float operandIn = (float)(token - '0');
                stack.push(operandIn);
            } else { // 运算符
                if (stack.size() < 2) {
                    throw new IllegalArgumentException("Invalid postfix expression: insufficient operands for operator " + token);
                }
                float operand_1 = stack.pop(); // 第一个弹出的操作数是右操作数
                float operand_2 = stack.pop(); // 第二个弹出的操作数是左操作数
                stack.push(calculate(operand_1, token, operand_2));
            }
            index += 1;
        }

        // 表达式求值完成后，栈中应只剩一个结果
        if (stack.size() != 1) {
            throw new IllegalArgumentException("Invalid postfix expression: too many operands or too few operators.");
        }
        return stack.pop();
    }

    public static void main(String[] args) {
        // 测试表达式：( (3 + (1 * 2)) + (4 + (5 * 6)) ) / (9 - 7)
        // 转换为后缀表达式：312*+456*+97-/+
        // 预期结果： ( (3 + 2) + (4 + 30) ) / 2 = (5 + 34) / 2 = 39 / 2 = 19.5
        // 实际上，原问题中的预期结果22.0对应的是 (312*+ 456*+ + 97- /) +  => ( (3+(1*2)) + (4+(5*6)) ) / (9-7) +  => (5+34)/2 + (什么也没有)
        // 根据后缀表达式的严格定义，"312*+456*+97-/+" 应该解析为：
        // A = 312*+ => 3 + (1*2) = 5
        // B = 456*+ =>