import java.util.LinkedList;

public class Pila<E> extends LinkedList<E> {

    public void empujar(E e ){
        super.addFirst(e);
    }

    public E remover(){
        return super.removeFirst();
    }

    public boolean estaVacia(){
        return super.size() == 0;
    }

    public String toString(){
        return super.toString();
    }
}


//representa una expresion matematica x + y * z etc..
public class ExpresionMatematica{
    private String expresion;
    private char[] exprArr;
    private int posActual = 0;

    public ExpresionMatematica(String expr){
        expresion = expr;
        exprArr = expr.toCharArray();
    }

    //retornar siguiente elemento como int  y no como char
    public int getElementoComoNum(){
        return Integer.parseInt(String.valueOf(getElemento()));
    }

    //revisar si el elemento siguiente es un nro
    public boolean elementoEsNum(){
        return Character.isDigit(exprArr[posActual]);
    }

    //revisa si el elemento siguiente es un operador
    public boolean elementoEsOp(){
        char ele = exprArr[posActual];
        return ele == '+' || ele == '-' || ele == '*' || ele == '/';
    }

    //determina si estamos al final de la expresion
    public boolean noAlFinalDeExpr(){
       return posActual != exprArr.length;
    }

    //regresar el elemento siguiente y aumentar posActual
    public char getElemento(){
       return exprArr[posActual++];
    }

    public String toString(){
       return expresion;
    }
}


//clase que calcula el valor de una expresion matematica
public class CalcExprMatematica {

    private Pila<Integer>  operandos;
    private Pila<Character> operadores;
    private ExpresionMatematica expr;

    public CalcExprMatematica(String exp){

        operandos = new Pila<>();
        operadores = new Pila<>();
        expr = new ExpresionMatematica(exp);
    }

    public String toString(){
        return expr +" = " + calcular();
    }

    //calcular el valor de la expresion
    int calcular(){
        while(expr.noAlFinalDeExpr()){
            if(expr.elementoEsOp()){
                char op = expr.getElemento();
                if(operadores.estaVacia()){operadores.empujar(op);}
                else{
                    char opRemovido = operadores.remover();
                    if(calcularPrecedenciaDeOp(op) > calcularPrecedenciaDeOp(opRemovido)){
                        operadores.empujar(opRemovido);
                    }else{
                        aplicarOperation(opRemovido);
                    }
                    operadores.empujar(op);
                }
                /*si el caracter siguiente es un nro se hace lo siguiente :
                apendar nros como string despues convertirlos int ejemplo : 20 + 4.
                 2 es numero, 0 es numero apendamos los nros 20. y lo empujamos a la pila
                 */
            }else if(expr.elementoEsNum()){
                StringBuilder numeros = new StringBuilder();
                while(expr.noAlFinalDeExpr() && expr.elementoEsNum()){
                    numeros.append(expr.getElementoComoNum());
                }
                operandos.empujar(Integer.parseInt(numeros.toString()));
            }
        }
        // si al final ahy operadores hay que aplicarlos hasta que no haigan mas
        while(!operadores.estaVacia()){
            aplicarOperation(operadores.remover());
        }
        return operandos.remover();
    }

    private int calcularPrecedenciaDeOp(char op){
        return op == '+' || op == '-'? 1 : 2;
    }

    private void aplicarOperation(char op){
        if(operandos.estaVacia()) throw new RuntimeException("SE operandos vacia");
        int y  = operandos.remover();
        if(operandos.estaVacia()) throw new RuntimeException("SE operandos vacia");
        int x  = operandos.remover();
        int z;

        if (op == '*') { z = x * y; }
        else if(op == '/'){
            if (y != 0) {
                z = x/y;
            }
            throw new ArithmeticException("division por 0");
        }
        else if (op == '+') { z = x + y; }
        else if (op == '+') { z = x - y; }
        else throw new RuntimeException("syntax error no es operador valido");
        operandos.empujar(z);
    }
}

public class CalculadorDeExprDemo {
    public static void main(String[] args)throws IOException {
        String expresion = JOptionPane.showInputDialog("ingrese expresion");
        CalcExprMatematica cal = new CalcExprMatematica(expresion);
        System.out.println(cal);
    }
}