自己实现Java_String里面的spilt方法，不能借助于string的任何的方法，类

class StrMethod{
    char[] data;

    // 默认构造方法，分配4k的长度
    public StrMethod() {
        data = new char[1024*4];
    }


    public StrMethod(char[] arrData) {
        data = new char[arrData.length];
        for (int i = 0; i < arrData.length; i++) {
            data[i] = arrData[i]; 
        }
    }

    // 拷贝构造函数
    public StrMethod(StrMethod strOri) {
        data = Arrays.copyOf(strOri.data, strOri.data.length);
    }

    public int getLen(){
        return data.length;
    }

    //数组比较
    private boolean arrCompare(char[] a,char[] b){
        if(a.length!= b.length){
            return false;
        }
        for (int i = 0; i < b.length; i++) {
            if (a[i]!=b[i]) {
                return false;
            }
        }
        return true;
    }

    //统计字符串出现的次数
    public int Count(StrMethod toFind){
        int count = 0;
        int toFindLen = toFind.data.length;//要找的字符串长度

        //要找的字符串比本字符串场，直接退出
        if(data.length<toFindLen){
            return 0;
        }

        for (int i = 0; i < data.length; i++) {
            //剩下的字符数组以及比需要找的串短，直接跳出循环
            if(i+toFindLen > data.length){
                break;
            }
            //新建一个字符数组
            char[] a = new char[toFindLen];

            //从第i个位置拷贝一定长度到临时字符数组
            System.arraycopy(data, i, a, 0, toFindLen);

            //如果新的数组a跟要查找的字符串的内容和长度相等就统计一下
            if (arrCompare(a,toFind.data)) {
                count++;
            }
        }
        return count;
    }

    /*在正则表达式之前出现的内容为一个段拷贝
     * 比如有一组原始数组arrStr：[123,abc,45]
     * 他的下标依次为：                               0123456789
     *    ','所在的位置：                             3   7
     * 原始数组被拆分成了两段形成了三组数组，下标依次为0、1、2
     * 
     * 当截取第一段数组123，i的起始位置为0，','的位置为0
     *      二            abc         4         7
     *      三           45          8          9
     * 当遍历到最后一段数组时，拷贝的数组长度为i-start+1 = 9-8+1=2
     */

    public StrMethod[] spilte(StrMethod regex){
            int nSpilteNum = 0;
            nSpilteNum = Count(regex);//统计分隔符数量

            StrMethod[] retStr;//返回的数组结果
            //如果包含分隔符
            //如果分隔符数量大于0，就给结果数组定义一个有分隔符数量大小的长度
            if (nSpilteNum > 0) {
                retStr = new StrMethod[nSpilteNum];
            }
            //如果不包含分隔符.就返回整个字符串
            else{
                retStr = new StrMethod[1];//开辟一个新的字符长度
                retStr[0] = new StrMethod(data);//把原数组的内容赋值给结果数组
                return retStr;
            }


            int index = 0;//返回数组的索引
            int start = 0;//正则表达式的起始位置
            for (int i = 0; i < data.length; i++) {

                //处理最后一个字符
                if (i == data.length - 1) {
                    char[] tmp = new char[i - start + 1];//定义一个临时数组
                    System.arraycopy(data, start, tmp, 0, i - start + 1);
                    retStr[index] = new StrMethod(tmp);

                }
                //截取字符串并拷贝到新的数组里
                if (data[i] == regex.data[0]) {
                    char[] tmp = new char[i-start];
                    System.arraycopy(data, start, tmp, 0, i+start);
                    retStr[index] = new StrMethod(tmp);
                    start = i+1;//，找到了正则表达式，正则表达式的位置往后移一位
                    index++;//原始数组继续向后查找
                }
            }
        return retStr;
    }

}