unable to correctly validate balanced parenthesis parsing in java method

Question

I have a method that's supposed to validate accurate opening and closing parenthesis in a string using java. This method will be used to parse mathematical expressions so it's important for the parenthesis to be balanced. For some reason, it is returning false in both of these runs:

System.out.println(parChecker("(()"));  // returns false :-)
System.out.println(parChecker("((()))")); // returns false :-(  WHY??

Here is the method that uses a stack to solve the problem. Something is wrong here becuase it's returning false for a balanced set of parenthesis as well. What's the problem? Thank you in advance.

public static boolean parChecker(String str) {
    String[] tokens = str.split("");
    int size = tokens.length;
    Stack theStack = new Stack(size);
    int index = 0;
    boolean balanced = true;
    while ((index < size) && balanced) {
        String symbol = tokens[index];
        if (symbol.equals("(")) {
            theStack.push(symbol);
        } else {
            if (theStack.isEmpty()) {
                balanced = false;
            } else {
                theStack.pop();
            }
        }
        index++;
    }

    if (balanced && theStack.isEmpty()) {
        return true;
    } else {
        return false;
    }

}

Here is my stack class that I'm using:

public class Stack {

    private Object [] stack;
    private int maxSize = 0;
    private int top;

    public Stack(int size){
        maxSize = size;
        stack = new Object[maxSize];
        top = -1;
    }

    public void push(Object obj){
        top++;
        stack[top] = obj;
    }

    public Object pop(){
        return stack[top--];
    }

    public Object peek(){
        return stack[top];
    }

    public boolean isEmpty(){
        return (top == -1);
    }

    public boolean isFull(){
        return (top == maxSize -1);
    }
}

Answer 1

The immediate problem is this

String[] tokens = str.split("");

Gives you first char = "" if you use java 1.7 or less, so you will exit your loop since stack is empty...

Note: this has been changed in java 1.8 split difference between java 1.7 and 1.8

change to:

char[] tokens = str.toCharArray();

I guess however that you need to consider the fact that there can be chars before your first ( and that you may have other chars then ( and )

Answer 2

As far as I can tell, there is no problem with the code (turns out it's a Java 7 specific issue..).

I would like to offer a replacement method though, for educational purposes, that is shorter, and and is tolerant of other characters being present:

public static boolean parChecker(String str) {
    Stack stack = new Stack(str.length());
    for (char c : str.toCharArray())
        switch (c) {
        case '(':
            stack.push(c);
            break;
        case ')':
            if (stack.isEmpty() || stack.pop() != Character.valueOf('('))
                return false;
        }
    return stack.isEmpty();
}

As requested, here's another solution that doesn't use a stack:

public static boolean parChecker(String str) {
    str = str.replaceAll("[^()]", "");
    while (str.contains("()"))
        str = str.replace("()", "");
    return str.isEmpty();
}

And one more for the road: @FredK's algorithm:

public static boolean parChecker(String str) {
    int depth = 0;
    for ( char c : str.toCharArray() )      
        if ( ( depth += c == '(' ? 1 : c == ')' ? -1 : 0 ) < 0 )
            return false;
    return depth == 0;
}