String 过滤字符串

package com.yuanls.dataqc.inter;

import java.util.ArrayList;
import java.util.HashMap;

public class FilterStrUtil {
    private int maxLength;

    private HashMap<String, String> filterStrs = new HashMap<String, String>();

    // 初始化需要过滤掉什么符号

    private String initStr(String value) {

        StringBuffer sb = new StringBuffer();

            sb.append(value);

        return sb.toString();
    }

    /**
     * 　　* str-被过滤得字符串
     *
     * 　　* s-需要过滤得字符串
     *
     * 　　* 获得剩下未过滤的字符串
     *
     * 　　
     */

    private String getNextStr(String str, int start, int slength) {

        if (start == 0) {

            str = str.substring(slength);

        } else if (start + slength < str.length()) {
            str = str.substring(start + slength);
        }
        return str;
    }

    /**
     * 　　* str-被过滤得字符串
     *
     * 　　* s-需要过滤得字符串
     *
     * 　　* 获得过滤后的字符串
     *
     * 　　
     */

    private StringBuffer getFilterStr(StringBuffer sb, String str, int start,
            String s) {

        if (start != 0) {

            sb.append(str.substring(0, start));

        }

        sb.append(filterStrs.get(s));

        return sb;
    }

    /**
     * 　　* str-被过滤的字符串
     *
     * 　　* 过滤，并组合过滤后的字符串
     *
     * 　　
     */

    public String filter(String str) {

        StringBuffer resultStr = new StringBuffer();

        for (int start = 0; start < str.length(); start++) {

            for (int end = start + 1; end <= str.length()
                    && end <= start + maxLength; end++) {

                String s = str.substring(start, end);

                int slength = s.length();

                if (filterStrs.containsKey(s)) {

                    resultStr = getFilterStr(resultStr, str, start, s);

                    str = getNextStr(str, start, slength);

                    start = 0;
                    end = start;
                }
            }
        }
        resultStr.append(str);
        return resultStr.toString();
    }

    public void put(String key,String value) {

        int keyLength = key.length();

        filterStrs.put(key, initStr(value));

        if (keyLength > this.maxLength)

            maxLength = keyLength;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        //要检测的字段集合
        ArrayList<String> needContro = new ArrayList<String>();
        
        needContro.add("-9999");
        needContro.add("234");
        needContro.add("+");
        needContro.add("");
        needContro.add("12");
        needContro.add("12.4");
        needContro.add(null);
        
        FilterStrUtil t=new FilterStrUtil();
        //特殊字符转换
        t.put("+","0");
        t.put("-9999","0");
        for(String str :needContro){
            //缺测代表值
            if(str==null||str.equals("")){
                str="-3";
                //continue;
            }
            System.out.println(t.filter(str));
        }

    }

}