正则表达式匹配

public class Solution {
    public boolean matchCore(char[] str,char[] pattern,int strIndex,int patternIndex){
    //str和pattern都刚好完成，则说明可以成功匹配
        if(strIndex==str.length&&patternIndex==pattern.length)
            return true;
//若pattern先于str遍历完，则肯定不能够成功匹配
        if(strIndex!=str.length&&patternIndex>=pattern.length)
            return false;
        //System.out.println("asd"+strIndex+" "+patternIndex);
    //如果str已经遍历完，而pattern还没有遍历完，有可能存在pattern存在a*a*这种情况，*每次都零次匹配
        if(strIndex==str.length&&patternIndex!=pattern.length){
            if(patternIndex+1<pattern.length&&pattern[patternIndex+1]=='*')
                return matchCore(str, pattern, strIndex, patternIndex+2);
            return false;
        }

        if(patternIndex<pattern.length-1&&pattern[patternIndex+1]=='*'){
            //System.out.println(strIndex+" "+patternIndex);
            if(pattern[patternIndex]==str[strIndex]||(pattern[patternIndex]=='.'&&strIndex!=str.length))
            //这一部分原理是编译原理里面的非确定性的有限状态机
                    return matchCore(str, pattern, strIndex+1, patternIndex+2)//移动到下一个元素，‘*’只匹配一次
                            ||matchCore(str, pattern, strIndex+1, patternIndex)//pattern不移动，str移动下一个，说明‘*’匹配多次
                            ||matchCore(str,pattern,strIndex,patternIndex+2);//这种情况了*号一次都不匹配，直接跳过‘*’号和‘*’之前的字母  
                else    return matchCore(str, pattern, strIndex, patternIndex+2);//这里很重要，在不相等的情况下，也可以直接跳过‘*’和其之前的字母

        }
        if(strIndex<str.length&&(pattern[patternIndex]==str[strIndex]||(strIndex!=str.length&&pattern[patternIndex]=='.')))
            return matchCore(str,pattern,strIndex+1,patternIndex+1);
        return false;
        } 
    public boolean match(char[] str, char[] pattern)
    {
        if(str.length==0&&(pattern.length==2&&pattern[1]=='*'))
            return true;
        if(str.length==0&&pattern.length==1&&pattern[0]=='.')
            return false;
       return matchCore(str,pattern,0,0);
    }

}