Java中后缀表达式求值：解决字符数值转换错误

char token = expr.charAt(index); // 从表达式中获取字符，例如 '3'
// ...
if (isOperand(token)) { // 如果是操作数
    float operandIn = (float)token; // 问题所在：将字符 '3' 直接转换为 float
    stack.push(operandIn);
}

// 错误的代码示例
// float operandIn = (float)token;
// stack.push(operandIn);

// 正确的代码示例：将字符 '3' 转换为数值 3
float operandIn = (float)(token - '0'); 
stack.push(operandIn);

float operandIn = (float)Character.getNumericValue(token);
stack.push(operandIn);

import java.util.Stack;

public class PostFixEvaluate {

    /**
     * 执行基本的算术运算。
     * @param operand_1 右操作数
     * @param operator 运算符
     * @param operand_2 左操作数
     * @return 运算结果
     * @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 IllegalArgumentException("Division by zero is not allowed!");
                }
                return operand_2 / operand_1;
            default:
                throw new IllegalArgumentException("Unknown operator: " + operator);
        }
    }

    /**
     * 对后缀表达式进行求值。
     * 注意：此实现目前仅支持单字符操作数和运算符，且不处理表达式中的空格。
     * 对于多位数字或带空格的表达式，需要更复杂的解析逻辑。
     * @param expr 后缀表达式字符串
     * @return 求值结果
     * @throws IllegalArgumentException 如果表达式无效（例如操作数不足或操作符过多）
     */
    public static float postFixEvaluation(String expr) {
        Stack<Float> stack = new Stack<>();

        for (int i = 0; i < expr.length(); i++) {
            char token = expr.charAt(i);

            if (isOperand(token)) { // 是操作数
                // 核心修正：将字符数字转换为其对应的数值
                float operandIn = (float)(token - '0'); // 或者使用 (float)Character.getNumericValue(token);
                stack.push(operandIn);
            } else { // 是操作符
                if (stack.size() < 2) {
                    throw new IllegalArgumentException("Invalid postfix expression: not enough operands for operator '" + token + "' at index " + i);
                }
                float operand_1 = stack.pop(); // 先弹出的作为右操作数
                float operand_2 = stack.pop(); // 后弹出的作为左操作数
                stack.push(calculate(operand_1, token, operand_2));
            }
        }

        if (stack.size() != 1) {
            throw new IllegalArgumentException("Invalid postfix expression: too many operands or too few operators.");
        }
        return stack.pop();
    }

    /**
     * 判断一个字符是否为操作数。
     * @param c 待判断字符
     * @return 如果是操作数返回 true，否则返回 false
     */
    public static boolean isOperand(char c) {
        switch (c) {
            case '+':
            case '-':
            case '*':
            case '/':
                return false; // 是操作符
            default:
                // 假设所有非运算符字符都是数字操作数。
                // 实际应用中可能需要更严格的数字判断，例如 Character.isDigit(c)
                return true; // 是操作数
        }
    }

    public static void main(String[] args) {
        // 测试原始问题中的表达式
        String expression1 = "312*+456*+97-/+"; // 期望结果: 22.0
        try {
            float result1 = postFixEvaluation(expression1);
            System.out.println("Expression: \"" + expression1 + "\"");
            System.out.println("Calculated Result: " + result1); 
            System.out.println("Expected Result: 22.0\n");
        } catch (IllegalArgumentException e) {
            System.err.println("Error evaluating expression \"" + expression1 + "\": " + e.getMessage() + "\n");
        }

        // 更多测试用例
        String expression2 = "52+"; // 5 + 2 = 7
        String expression3 = "63/2*"; // (6 / 3) * 2 = 4
        String expression4 = "10+"; // 无效表达式，操作数不足
        String expression5 = "123++"; // (1+2)+3 = 6

        try {
            System.out.println("Expression: \"" + expression2 + "\", Result: " + postFixEvaluation(expression2));
            System.out.println("Expression: \"" + expression3 + "\", Result: " + postFixEvaluation(expression3));
            System.out.println("Expression: \"" + expression5 + "\", Result: " + postFixEvaluation(expression5) + "\n");
        } catch (IllegalArgumentException e) {
            System.err.println("Error evaluating expression: " + e.getMessage() + "\n");
        }

        try {
            System.out.println("Expression: \"" + expression4 + "\", Result: " + postFixEvaluation(expression4) + "\n");
        } catch (IllegalArgumentException e) {