校驗括號及獲取相應位置括號對應的另一半括號

package com.demo;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
	
	public static void main(String[] args) {
		String a = "vab(c([]){a[()d]{}()}sa)";
		System.out.println(isMatch(a));
		Integer r = bracketsMatchedSearchByLeft(a.toCharArray(), 5);
		System.out.println(r);
		Integer l = bracketsMatchedSearchByRight(a.toCharArray(), 8);
		System.out.println(l);
	}
	
	/**
	 * 通過左括號的位置得到匹配的右括號的位置
	 * 
	 * 返回對應座標爲正常，
	 * -1表示傳進來的座標不是左括號
	 * -2表示不存在對應右括號（不應該出現，應該提前校驗過括號配對）
	 * 
	 * @param checkedCharArray
	 * @param leftIndex
	 * @return
	 */
	public static Integer bracketsMatchedSearchByLeft (char[] checkedCharArray, int leftIndex) {
		
		// 校驗傳進來的數組和索引是否爲合法
		if(checkedCharArray.length < leftIndex || leftIndex < 0) {
			return -1;
		}
		
		char left = checkedCharArray[leftIndex];
		// 非左括號或空格
		if(!('(' == left || '[' == left || '{' == left)) {
			return -1;
		}
		
		/*
		 *  獲取傳進來的是第幾個左括號
		 */
		int index = 0;
		Matcher matcher = Pattern.compile("\\(|\\[|\\{").matcher(new String(checkedCharArray));
		while(matcher.find()) {
			index++;
			if(matcher.start() == leftIndex) {
				break;
			}
		}
		/*
		 *  獲取另一配對括號位置
		 */
		Stack<Character> bracketsStack = new Stack<Character>();
		int count = 0;
		for (int i = 0; i < checkedCharArray.length; i++) {
			char c = checkedCharArray[i];
			
			// 左括號都壓入棧頂，右括號進行比對
			if(c == '(' || c == '[' || c == '{') {
				count++;
				// 如果是目標，就插入*作爲標記
				if(index == count) {
					bracketsStack.push('*');
				} else {
					bracketsStack.push(c);					
				}
			} else if(c == ')' || c == ']' || c == '}') {
				// 棧非空校驗，防止首先出現的是右括號
				if(bracketsStack.isEmpty()) {
					return -2;
				}
				Character popChar = bracketsStack.pop();
				if('*' == popChar) {
					return i;
				}
			}
		}
		
		return -2;
	}
	
	/**
	 * 校驗字符串中的括號是否匹配
	 * @param s
	 * @return
	 */
	public static boolean isMatch(String s){
        //定義左右括號的對應關係
        Map<Character,Character> bracket  = new HashMap<Character, Character>();
        bracket.put(')','(');
        bracket.put(']','[');
        bracket.put('}','{');

        Stack<Character> stack = new Stack<Character>();

        for(int i = 0; i < s.length(); i++){
            Character temp = s.charAt(i);//先轉換成字符
            //是否爲左括號
            if(bracket.containsValue(temp)){
                stack.push(temp);
                //是否爲右括號
            }else if(bracket.containsKey(temp)){
                if(stack.isEmpty()){
                    return false;
                }
                //若左右括號匹配
                if(stack.peek() == bracket.get(temp)){
                    stack.pop();
                }
                else{
                    return false;
                }
            }
        }
        return stack.isEmpty()? true: false;

    }
	
	/**
	 * 通過右括號的位置得到匹配的左括號的位置
	 * 
	 * 返回對應座標爲正常，
	 * -1表示傳進來的座標不是右括號
	 * -2表示不存在對應右括號（不應該出現，應該提前校驗過括號配對）
	 * 
	 * @param checkedCharArray
	 * @param leftIndex
	 * @return
	 */
	public static Integer bracketsMatchedSearchByRight (char[] checkedCharArray, int rightIndex) {
		
		// 校驗傳進來的數組和索引是否爲合法
		if(checkedCharArray.length < rightIndex || rightIndex < 0) {
			return -1;
		}
		
		char right = checkedCharArray[rightIndex];
		// 非左括號或空格
		if(!(')' == right || ']' == right || '}' == right)) {
			return -1;
		}
		
		/*
		 *  獲取另一配對括號位置
		 */
		Stack<Character> bracketsStack = new Stack<Character>();
		for (int i = rightIndex; i > 0; i--) {
			char c = checkedCharArray[i];
			
			// 左括號都壓入棧頂，右括號進行比對
			if(c == ')' || c == ']' || c == '}') {
				// 如果是目標，就插入*作爲標記
				if(i == rightIndex) {
					bracketsStack.push('*');
				} else {
					bracketsStack.push(c);					
				}
			} else if(c == '(' || c == '[' || c == '{') {
				// 棧非空校驗，防止首先出現的是右括號
				if(bracketsStack.isEmpty()) {
					return -2;
				}
				Character popChar = bracketsStack.pop();
				if('*' == popChar) {
					return i;
				}
			}
		}
		
		return -2;
	}
}