2.编写一个字符串处理功能类：StringProcessor
有如下方法：
(1) public static String getSubString(String s, int beginNum, int endNum) throws Exception
取得原始字符串s的前beginNum和后endNum个字符之间的子字符串。
(2) public static String getSubString(String s1, String s2 ) throws Exception取得S1中第一次出现S2和最后一次出现S2之间的字符串。如果S1中没有出现S2，或只出现S2一次则抛出异常。
(3) public static String reverse(String s1) throws Exception将原始的字符串s1所有字符倒排后，返回。编写测试主类Test, 对此类进行测试。

package StringProcessor;

public class StringPrcessor {
    //给定字符串  去掉前 beginnum个字母  去掉后 endnum个字母
    public static String getSubString(String s,int beiginNum,int endNum)throws Exception{

        // 前几个字母不要 3个不要就从3开始  因为3是第四个
        int preindex=beiginNum;
        // 后几个字母不要,lenth-endnum 就是最后位置+1,一会判定是<lastnum不会越界
        int lastindex=s.length()-endNum;
        //
        if(lastindex<=preindex){
            throw new NullPointerException("结尾索引小于开始索引或没有可返回字符");
        }

        int j=0;
        char[] c1=new char[lastindex-preindex];
        for(int i=preindex;i<lastindex;i++)
        {
            c1[j]=s.charAt(i);
            j++;
        }
        StringBuffer sb=new StringBuffer("");
        for(int i=0;i<lastindex-preindex;i++){
            sb.append(c1[i]);
        }
        String s2=sb.toString();
        return s2;
    }
    //取得在 s1中 s2第一次和最后一次出现  之间的字符串  如果s1没有出现或者只有一次  则抛出异常
    public static String getSubString(String s1,String s2)throws Exception{
        if(s1==null||s2==null){
            throw new NullPointerException("字符串为空!");
        }
        if(s1.length()<=0||s2.length()<=0){
            throw new NullPointerException("字符串为空!");
        }
        //s1 和 s2 分别存入 c1  c2字符数组
        char[] c1=new char[s1.length()];
        for(int i=0;i<s1.length();i++){
            c1[i]=s1.charAt(i);
        }
        char[] c2=new char[s2.length()];
        for(int i=0;i<s2.length();i++){
            c2[i]=s2.charAt(i);
        }
        //设置标志变量  flag
        int flag=0;
        // 设置标志变量2 flag2 防止 preindex被重复累加
        int flag2=0;
        //设置标志变量3 flag3 防止 lastindex被重复累加
        int flag3=0;
        // 设置计数变量 count
        int count=0;
        //设置 需要截取片段的首尾索引
        int preindex = 0;
        int lastindex = 0;
        //内层循环中的 j 在外部定义
        int j=0;
        //遍历大字符串 s1
        for( int i=0  ;i<s1.length();i++){
            //遇到 c1的头 与 c2的头部相同 开始校验 小字符串
            if(c1[i]==c2[0]){
                //按照c2的长度开始逐个比较
                for(   ;j<s2.length()  ;j++){
                    if(c1[i+j]==c2[j]){
                        flag=1;
                    }else {
                        flag=0;
                    }
                }
            }
            //如果小字符串全部校验成功 flag会是1
            if(flag==1){
                count ++;
                lastindex=i;
                flag=0;
            }
            //如果是 第一次校验成功的话  记录下 preindex
            if(count==1&&flag2==0){
                preindex=i+j;
                flag2=1;
            }
            // 重置内层循环变量 j,因为需要统计  i+j所以j放在外面总结用
            j=0;
        }
        //全部完成后  建立字符串 开始返回值
        StringBuffer sb=new StringBuffer("");
        if(count>1){
            for(int x=preindex;x<lastindex;x++){
                sb.append(c1[x]);
            }
        }else{
            throw new Exception("字符串少于两组");
        }
        String result=sb.toString();
        return result;
    }
    //讲字符串 s1 倒排后返回
    public static String reverse(String s1)throws Exception{
        StringBuffer sb= new StringBuffer("");
        //把 s1 字符串的索引反向添加到 sb字符串中
        for(int i=s1.length()-1;i>=0;i--){
            sb.append(s1.charAt(i));
        }
        String result=sb.toString();
        return result;
    }
}