正则表达式匹配

题目：
请实现一个函数用来匹配包含‘.'和’*'的正则表达式
‘ . ’ 表示与任意字符相匹配
’ * ’表示上一个字符出现0次一次多次
每轮匹配中，模式串的第二个字符是 “ * ”时
第一个字符不匹配，只能代表匹配零次
第一个字符匹配，0，1，多次
声明布尔类型函数，形参为字符串和模式串，
判断字符串和模式串都不为空
返回核心方法
核心方法四个形参
字符串，字符串索引，模式串，模式串索引
如果字符串索引等于字符串长度，且模式串索引等于模式串长度那么匹配成功，退出递归
如果字符串索引小于字符串长度且模式串索引等于模式串长度，匹配失败退出递归
如果模式串索引的下一位就是*，
如果字符串索引小于字符串长度且模式串的索引位是 . // .*
或者字符串的索引小于字符串的长度，且模式串中的字符等于字符串的字符//说明有匹配
返回字符串匹配零次，一次，多次的可能，//用递归，将所有的可能性都做出计算，只要有能得出结论的就为true
如果模式串索引的下一位就是*，但是没有找到也没有在相同的索引位置发现字符匹配
模式串后移两位
当字符串和模式串相等或者模式串中有一个字符 . 可以比较下一位
package com.helan.c;

public class Match {
public static boolean match(char []str,char []pattern){
if(strnull||patternnull){
return false;
}
return matchCore(str,0,pattern,0);
}
//abbbh abh abh a.bbh
private static boolean matchCore(char[] str, int indexOfStr, char[] pattern, int indexOfPattern) {
if(str.lengthindexOfStr&&pattern.lengthindexOfPattern){
return true;
}
if(indexOfStr<str.length&&pattern.lengthindexOfPattern){
return false;
}
if(indexOfPattern+1<pattern.length&&pattern[indexOfPattern+1]’*’){
if(indexOfStr<str.length&&pattern[indexOfPattern]==’.’||
indexOfStr<str.length&&pattern[indexOfPattern]str[indexOfStr]
){
//a *字符匹配0次，字符串字符位置不变 模式串后移两个字符
return matchCore(str,indexOfStr,pattern,indexOfPattern+2)||
//b * 字符匹配1次，字符串后移一个字符 模式后移两个字符 继续比较
matchCore(str,indexOfStr+1,pattern,indexOfPattern+2)||
//c * 字符匹配多次 字符串后移一个字符，模式匹配字符位置不变，继续比较
matchCore(str,indexOfStr+1,pattern,indexOfPattern);
}else{//没有找到. 也没有在相同索引的位置发现字符匹配，
return matchCore(str,indexOfStr,pattern,indexOfPattern+2);
}
}
if(str.length>indexOfStr&&(pattern[indexOfPattern]’.’||str[indexOfStr]==pattern[indexOfPattern])){
return matchCore(str,indexOfStr+1,pattern,indexOfPattern+1);

    }
    return false;
}
void test(String testName, char[] str, char[] pattern, boolean expected) {
    System.out.print(testName + ":");
    if (match(str, pattern) == expected) {
        System.out.println("passed!");
    }else {
        System.out.println("failed!");
    }
}
void test1() {
    char[] str = {};
    char[] pattern = { '.' };
    test("test1", str, pattern, false);//期望为false
}

void test2() {
    char[] str = {};
    char[] pattern = { '.', '*' };
    test("test2", str, pattern, true);
}

void test3() {
    char[] str = { 'a' };
    char[] pattern = { '.', '*' };
    test("test3", str, pattern, true);
}

void test4() {
    char[] str = {};
    char[] pattern = {};
    test("test4", str, pattern, true);
}

void test5() {
    char[] str = null;
    char[] pattern = null;
    test("test5", str, pattern, false);
}

void test6() {
    char[] str = { 'a', 'b', 'b','b','c' };
    char[] pattern = { 'a', 'b', 'b', '*', 'b','c' };
    System.out.println(str[2]+"---"+pattern[3]);
    test("test6", str, pattern, true);
}

void test7() {
    char[] str = { 'a' };
    char[] pattern = { 'a',  'b','*' };
    test("test7", str, pattern, true);
}

public static void main(String[] args) {
    Match demo = new Match();
    demo.test1();
    demo.test2();
    demo.test3();
    demo.test4();
    demo.test5();
    demo.test6();
    demo.test7();
}

}