Javaで負号で始まる式を処理する方法

I've been trying to fix this so that the code would be able to handle expressions that start with a negative sign (-). I've tried numerous methods but nothing seems to work.

Example inputs that I would like to work on: -2x^2+5x, -x^2+3x+5,-sin(x), etc. anything that starts with a negative.

I am using exp4j library.

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

Here is the 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");
        }
    }
}

I tried adding this line in the getTree() method:

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());
        }

It works fine with equations with exponent 2 or below but gives the wrong value when the exponent is 3 and above.