Utilização de Pilha para resolver expressões

Olá pessoal, estou tentando criar um programa que transforma uma expressão em notação infixa para posfixa, porém alguns erros estão ocorrendo…Ficaria agradecido com a ajuda de vocês!

Segue o código

//Classe Pilha
public class Pilha {

    //Supondo que os elementos armazenados sejam inteiros, a variavel topo controla o ultimo elemento da pilha do vetor.
    private char elementos[];
    private int topo;

    //Construtor - cria a pilha
    public Pilha(int n) {
        this.elementos = new char[n];
        this.topo = -1;//Pilha vazia
    }

    //push - empilhar
    public void push(char elemento) {
        if (topo < elementos.length - 1) {
            this.elementos[++topo] = elemento;
        } else {
            //Gerar uma exceção para avisar estouro de pilha
            System.out.println("Substituir por uma exceção");
        }
    }

    //pop - desempilhar
    public char pop() {
        char e = 'E';
        if (!isEmpty()) {
            return elementos[topo--]; //decrementa o topo depois de retornar
        } else {
            System.out.println("Gerar uma exceção para dizer que está vazio.");
            return e;
        }
    }

    public int getTopo() {
        return topo;
    }

    @Override
    public String toString() {
        String resp = "";
        for (int i = 0; i <= topo; i++) {
            resp += elementos[i] + " ";
        }
        return resp;
    }

    //isEmpty - ver se está vazia
    public boolean isEmpty() {
        return this.topo == -1;
    }

}

//Classe principal
public class PosfixaInfixav2 {

    public static void main(String[] args) {
        toPostfix("4 * ( 9 / 3 + 2 ) – 1".split(" "));
    }

    private static int toPostfix(String[] caracteres) {
        Pilha output = new Pilha(50);
        Pilha operatorStack = new Pilha(50);

        for (String caractere : caracteres) {
            char token = caractere.charAt(0);

            if (isOperator(token)) { //O token é operador
                System.out.println(token + " é operador");
                if (operatorStack.isEmpty()) { //pilha de operadores vazia
                    operatorStack.push(token);
                } else { //pilha de operadores preenchida
                    char popped = operatorStack.pop();
                    if (!isOperator(popped)) { //O valor puxado da pilha de operadores é um operador
                        System.out.println(popped + "não é operador (popped)");
                        operatorStack.push(popped);
                        operatorStack.push(token);
                    } else { //O valor puxado é um operador
                        System.out.println(popped + " é operador (popped)");
                        if (precedence(token) < precedence(popped)) { //O token tem precedencia maior que o que foi puxado da pilha de operadores
                            operatorStack.push(popped);
                            operatorStack.push(token);
                        } else { //O token tem precedencia menor que o que foi puxado da pilha de operadores
                            output.push(token);
                            operatorStack.push(popped);
                        }
                    }

                }
            } else if (Character.isDigit(token)) { //É número
                System.out.println(token + " é número");
                output.push(token);
            } else if (token == ')') { //É número
                while (!operatorStack.isEmpty()) {                    
                    char value = operatorStack.pop();
                    if (value != '(') {
                        output.push(value);
                    }
                }
            } else if (token == '(') { //É número
                operatorStack.push(token);
            }
            
            System.out.println("Output: " + output);
            System.out.println("Stack: " + operatorStack + "\n");
        }

        int topo = operatorStack.getTopo();

        while (topo != -1) {
            output.push(operatorStack.pop());
            topo = operatorStack.getTopo();
        }

        System.out.println("Fim: " + output);
        
        return 0;
    }

    private static boolean isOperator(char element) {
        return (element == '+' || element == '-' || element == '/' || element == '%' || element == '*');
    }

    private static int precedence(char operador) {

        if (operador == '^') {
            return 1;
        } else if (operador == '/' || operador == '*' || operador == '%') {
            return 2;
        }
        return 3;

    }

}

//Algoritmo sendo seguido

quais erros estão acontecendo?