给定一个由括号([{)]}其中之一或多个组成的字符串判断是否符合左右括号成对标准，不同括号可任意嵌套

需求：给定一个由括号([{)]}其中之一或多个组成的字符串判断是否符合左右括号成对标准，不同括号可任意嵌套

只有单个左或右括号 均不符合
 )(、}{、][ 不符合
 (){}[] 符合
 ({[]}) 符合
 ({}[)] 符合
 ()() 符合 左括号位置：0 2 右括号位置：1 3
 (()) 符合 左括号位置： 0 1 右括号位置：2 3
 ((()))(()()) 符合 左括号位置：0 1 2 6 7 9 右括号位置：3 4 5 8 10 11
 符合返回true,否则为false
 ({[{]}}{}())
 (())+{{}}{}+[] 其实最终与是否嵌套是无关的
 左右括号个数相等且左括号所在的最大位置比右括号所在的最大位置小即符合

源代码如下MatchTest.java：

package com.test.zhipengs;
/**
 * A Question
 * 给定一个由括号([{)]}其中之一或多个组成的字符串判断是否符合左右括号成对标准，不同括号可任意嵌套
 * 只有单个左或右括号 均不符合
 * )(、}{、][ 不符合
 * (){}[] 符合
 * ({[]}) 符合
 * ({}[)] 符合
 * ()() 符合  左括号位置：0 2  右括号位置：1 3  
 * (()) 符合  左括号位置： 0 1  右括号位置：2 3  
 * ((()))(()()) 符合  左括号位置：0 1 2 6 7 9  右括号位置：3 4 5 8 10 11
 * 符合返回true,否则为false
 * ({[{]}}{}())
 * (())+{{}}{}+[] 其实最终与是否嵌套是无关的
 * 左右括号个数相等且左括号所在的最大位置比右括号所在的最大位置小即符合
 * 
 * @author zhipengs
 * 
 */
public class MatchTest {
    /**
     * main方法
     * @param args
     */
    public static void main(String[] args) {
        // 测试isMatch(String str)方法
        String str1 = "(";
        System.out.println(str1+"  =====  "+isMatch(str1));
        String str2 = "[";
        System.out.println(str2+"  =====  "+isMatch(str2));
        String str3 = "{";
        System.out.println(str3+"  =====  "+isMatch(str3));
        System.out.println("----------------------------");
        String str4 = ")";
        System.out.println(str4+"  =====  "+isMatch(str4));
        String str5 = "]";
        System.out.println(str5+"  =====  "+isMatch(str5));
        String str6 = "}";
        System.out.println(str6+"  =====  "+isMatch(str6));
        System.out.println("----------------------------");
        String str7 = ")(";
        System.out.println(str7+"  =====  "+isMatch(str7));
        String str8 = "][";
        System.out.println(str8+"  =====  "+isMatch(str8));
        String str9 = "}{";
        System.out.println(str9+"  =====  "+isMatch(str9));
        System.out.println("----------------------------");
        String str10 = "))";
        System.out.println(str10+"  =====  "+isMatch(str10));
        String str11 = "[[";
        System.out.println(str11+"  =====  "+isMatch(str11));
        System.out.println("----------------------------");
        String str12 = "()";
        System.out.println(str12+"  =====  "+isMatch(str12));
        String str13 = "[[]]";
        System.out.println(str13+"  =====  "+isMatch(str13));
        String str14 = "{}{}";
        System.out.println(str14+"  =====  "+isMatch(str14));
        System.out.println("----------------------------");
        String str15 = "(()())()";
        System.out.println(str15+"  =====  "+isMatch(str15));
        String str16 = "[({}{()})]";
        System.out.println(str16+"  =====  "+isMatch(str16));
        String str17 = "{({[})}]";
        System.out.println(str17+"  =====  "+isMatch(str17));
        
    }

    /**
     * 具体的判断是否符合标准的方法
     * @param str
     * @return boolean
     */
    private static boolean isMatch(String str) {
        boolean isMatch = false;
        int len = str.length();
        if (null == str || len <= 1) {
            return isMatch;
        }
        char[] charArray = str.toCharArray();
        int smallLeft = 0, smallRight = 0, midLeft = 0, midRight = 0, bigLeft = 0, bigRight = 0;
        for (int i = 0; i < len; i++) {
            switch (charArray[i]) {
            case '(':
                smallLeft++;
                break;
            case ')':
                smallRight++;
                break;
            case '[':
                midLeft++;
                break;
            case ']':
                midRight++;
                break;
            case '{':
                bigLeft++;
                break;
            case '}':
                bigRight++;
                break;
            default:
                break;
            }
        }
        if ((smallLeft == smallRight)
                && str.lastIndexOf("(") <= str.lastIndexOf(")")) {
            isMatch = true;
        } 
        if ((midLeft == midRight) && isMatch
                && str.lastIndexOf("[") <= str.lastIndexOf("]")) {
            isMatch = true;
        } else {
            isMatch = false;
        }
        if ((bigLeft == bigRight) && isMatch
                && str.lastIndexOf("{") <= str.lastIndexOf("}")) {
            isMatch = true;
        } else {
            isMatch = false;
        }
        return isMatch;
    }
}

main方法输出结果如下：

( ===== false
[ ===== false
{ ===== false
----------------------------
) ===== false
] ===== false
} ===== false
----------------------------
)( ===== false
][ ===== false
}{ ===== false
----------------------------
)) ===== false
[[ ===== false
----------------------------
() ===== true
[[]] ===== true
{}{} ===== true
----------------------------
(()())() ===== true
[({}{()})] ===== true
{({[})}] ===== true

总结：只要了解字符串中最后面一个某特定字符所在的位置的方法lastIndexOf()以及对判断是否符合的条件分析出来即可完成需求---坑跌的鄙视！