使用栈实现括号匹配

public class ParenthesisMatchingTest {

    public static void main(String[] args) {
        String par01 = "(){([])}"; // true
        String par02 = "{}({({})}"; // false
        String par03 = "{(})"; // false
        String par04 = "{([])}]"; // false
        String par05 = "]()]"; // false

        System.out.println(parenthesisMatching(par01));
        System.out.println(parenthesisMatching(par02));
        System.out.println(parenthesisMatching(par03));
        System.out.println(parenthesisMatching(par04));
        System.out.println(parenthesisMatching(par05));
    }

    private static boolean parenthesisMatching(String str){
        MyArrayStack<Character> myArrayStack = new MyArrayStack<>(str.length());
        char[] parChar = str.toCharArray();
        Character pop;
        for(char parCh : parChar){
            switch (parCh){
                case '{' :
                case '[' :
                case '(' :
                    myArrayStack.push(parCh);
                    break;
                case '}' :
                    if(myArrayStack.isEmpty()) {
                        return false; // 如果栈已经为空，则证明之前已经都匹配完成，新入的符号不符合括号匹配规则
                    } else {
                        pop = myArrayStack.pop();
                        if('{' != pop){
                            return false; // 如果新入的符号与上一个符号不匹配，则不符合括号匹配规则
                        }
                    }
                    break;
                case ']' :
                    if(myArrayStack.isEmpty()) {
                        return false; // 如果栈已经为空，则证明之前已经都匹配完成，新入的符号不符合括号匹配规则
                    } else {
                        pop = myArrayStack.pop();
                        if('[' != pop){
                            return false; // 如果新入的符号与上一个符号不匹配，则不符合括号匹配规则
                        }
                    }
                    break;
                case ')' :
                    if(myArrayStack.isEmpty()) {
                        return false; // 如果栈已经为空，则证明之前已经都匹配完成，新入的符号不符合括号匹配规则
                    } else {
                        pop = myArrayStack.pop();
                        if('(' != pop){
                            return false; // 如果新入的符号与上一个符号不匹配，则不符合括号匹配规则
                        }
                    }
                    break;
            }

        }
        // 防止这种情况 {(),比如par02
        if (myArrayStack.isEmpty()){
            return true;
        } else {
            return false;
        }
    }
}

/**
 * 使用数组实现的一个栈
 * @param <T>
 */
class MyArrayStack<T> {

    private T[] arrayStack = (T[]) new Object[1];
    private int stackSize = 0; // 当前栈中已存的数据量

    /**
     * 构造函数，参数值为初始化数组的长度
     * @param length
     */
    public MyArrayStack(int length) {
        arrayStack = (T[]) new Object[length];
    }

    /**
     * 入栈一个元素
     * 如果stackSize大于length的0.75,则扩大二倍，
     * @param t
     */
    public void push(T t){
        if(stackSize > arrayStack.length * 0.75 - 1) {
            T[] newArrayStack = (T[]) new Object[arrayStack.length * 2];
            System.arraycopy(arrayStack, 0, newArrayStack, 0, arrayStack.length - 1);
            arrayStack = newArrayStack;
        }
        arrayStack[stackSize++] = t;
    }

    /**
     * 出栈一个元素
     */
    public T pop(){
        T t = arrayStack[--stackSize];
        arrayStack[stackSize] = null;
        return t;

    }

    /**
     * 当前栈是否为空
     * @return
     */
    public boolean isEmpty(){
        return 0 == stackSize;
    }
}

结果：

true
false
false
false
false