Expression Evaluator

import java.util.Stack;

public class ExpressionEvaluator {
    private String expression;
    private String[] expList;
    private String[] operators = {"√", "x", "/", "+", "-"};
    private String[] operands = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
    private Stack expressStack;

    public ExpressionEvaluator(String expression){
        this.expression = expression;
        //Creates stack for later usage when solving expression
        expressStack = new Stack();
        //Creates new array the length of expression split.
        expList = new String[this.expression.split(" ").length];

        //Add each element from the expression split to the new Array
        for(int i = 0; i < this.expression.split(" ").length; i++){
            expList[i] = this.expression.split(" ")[i];
        }
    }

    //Solve
    public double solve(){
        double answer = 0;
        String postFixExpression = parse(expression);
        String[] postFixSolve = new String[postFixExpression.length()];

        for(int i = 0; i < postFixSolve.length; i++){
            postFixSolve[i] = postFixExpression.split(" ")[i];
        }

        for(int i = 0; i < postFixSolve.length; i++){
            String currentElement = postFixSolve[i];

            if(isOperand(currentElement)){
                expressStack.push(Double.parseDouble(currentElement));
            }else if(isOperator(currentElement)){
                double num1 = (double)expressStack.pop();
                double num2 = (double)expressStack.pop();

                switch(currentElement){
                    case "x":
                        expressStack.push(num1 * num2);
                        break;
                    case "/":
                        expressStack.push(num1 / num2);
                        break;
                    case "+":
                        expressStack.push(num1 + num2);
                        break;
                    case "-":
                        expressStack.push(num1 - num2);
                        break;
                }
            }
        }

        System.out.println((double)expressStack.pop());

        return answer;
    }

    //Convert expression to post-fix
    public String postFixIt(){
        String postFixed; //Return value
        StringBuilder sb = new StringBuilder();
        Stack<String> myStack = new Stack<>();

        int numOfOperands = 0;

        for(int i = 0; i < expList.length; i++){
            String currentElement = parse(expList[i]);

            if(isOperand(currentElement)){
                sb.append(currentElement + " ");
                numOfOperands++;
            }else if(isOperator(currentElement) && myStack.isEmpty()){
                myStack.push(currentElement);
            }

            if(numOfOperands == 2){
                sb.append(myStack.pop() + " ");
                numOfOperands = 1;
            }
        }

        postFixed = sb.toString().trim();

        return postFixed;
    }

    public int comparePrecedence(String op1, String op2){
        int returnVal = 0;



        return returnVal;
    }

    //Checks to see if it is a number
    public boolean isOperand(String testOperand){

        for(String operand : operands){
            if(testOperand.contains(operand))
                return true;
        }

        return false;
    }

    //Checks to see if it is a operator
    public boolean isOperator(String testOperator){

        for(String operator : operators){
            if(testOperator.equals(operator))
                return true;
        }

        return false;
    }

    //Parses a string that is given to it
    public String parse(String parseString){
        String parsed;
        StringBuilder sb = new StringBuilder();

        if(parseString.contains("(") || parseString.contains(")")){
            String[] parseStringList = parseString.split("");
            for(String parse : parseStringList){
                if(parse.equals("(") || parse.equals(")")){
                    System.out.print(".");
                }else{
                    sb.append(parse);
                }
            }

            parsed = sb.toString().trim();
        }else{
            parsed = parseString.trim();
        }

        return parsed;
    }
}