Java中如何处理以负号开头的表达式？（基于exp4j库）

我尝试修复代码，使其能够处理以负号（-）开头的表达式，例如-2x^2+5x、-x^2+3x+5、-sin(x)等，但尝试多种方法均无效。使用exp4j库时会抛出错误：

Exception in thread "main" tokenizer.TokenizerException: Invalid expression

以下是我的Abstract Tree Builder代码：

package tokenizer;

import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import ast.*;
import net.objecthunter.exp4j.tokenizer.*;

public class AbstractTreeBuilder {

    private String f;
    private static Iterator<Token> it = null;

    public AbstractTreeBuilder(String f) {
        if (f == null) {
            throw new IllegalArgumentException("Invalid expression");
        }
        this.f = f;
        init();
    }

    private void init() {
        ExpressionParser expBuilder = new ExpressionParser(f);
        List<Token> li = Arrays.asList(expBuilder.variable("x").build());
        Collections.reverse(li);
        it = li.iterator();
    }

    private Operation getFunction(Token t) throws TokenizerException {
        FunctionToken token = (FunctionToken) t;
        switch (token.getFunction().getName()) {
            case "acos":
                return new Acos(getTree());
            case "asin":
                return new Asin(getTree());
            case "atan":
                return new Atan(getTree());
            case "log":
                return new Log(getTree());
            case "cos":
                return new Cos(getTree());
            case "sin":
                return new Sin(getTree());
            case "sqrt":
                return new Sqrt(getTree());
            case "tan":
                return new Tan(getTree());
            case "exp":
                return new Exp(getTree());
            case "abs":
                return new Abs(getTree());
            default:
                throw new TokenizerException("Function error");
        }
    }

    private Operation getOperator(Token t) throws TokenizerException {
        Operation right = getTree();
        Operation left = getTree();

        switch (((OperatorToken) t).getOperator().getSymbol()) {
            case "+":
                return new Addition(left, right);
            case "-":
                return new Subtraction(left, right);
            case "*":
                return new Product(left, right);
            case "/":
                return new Division(left, right);
            case "^":
                return new Pow(left, right);
            default:
                throw new TokenizerException("Function error");
        }
    }


    public Operation getTree() throws TokenizerException {
        if (!it.hasNext()) {
            throw new TokenizerException("Invalid expression ");
        }

        Token token = it.next();


        switch (token.getType()) {
            case Token.TOKEN_FUNCTION:
                return getFunction(token);
            case Token.TOKEN_NUMBER:
                return new Constant("" + ((NumberToken) token).getValue());
            case Token.TOKEN_OPERATOR:
                return getOperator(token);
            case Token.TOKEN_PARENTHESES_OPEN:
                return getTree();
            case Token.TOKEN_PARENTHESES_CLOSE:
                return getTree();
            case Token.TOKEN_VARIABLE:
                return new SimpleVar();
            default:
                throw new TokenizerException("Invalid expression");
        }
    }
}

我曾在getTree()方法中添加如下代码：

if (token.getType() == Token.TOKEN_OPERATOR && ((OperatorToken) token).getOperator().getSymbol().equals("-")) {
            isFirstTerm = false; // Reset the flag after processing the first term
            System.out.println("Creating Negate operation");
            return new Negate(getTree());
        }

该修改对指数为2及以下的表达式有效，但指数为3及以上时会返回错误结果。

内容的提问来源于stack exchange，提问作者Allysa Hipolito