敏感词过滤

package cn.xjw;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;



/**
 * 敏感词过滤 工具类   -- 【匹配度高，可以使用】
 *
 * * *  CensorWords.txt文件要求路径在src或resource下，默认文件名为CensorWords.txt
 *
 */
public class SensitiveWordUtil {
    private static StringBuilder replaceAll;//初始化
    private static final String encoding = "UTF-8";
    private static final String replceStr = "*";
    private static final int replceSize = 500;//过滤字符串的最大长度
    private static final String fileName = "CensorWords.txt";
    private static List<String> arrayList;//加载敏感词库

    /**
     * @param str 将要被过滤信息
     * @return 过滤后的信息
     */
    public static String filterInfo(String str) {
        // 初始化敏感词库
        InitializationWork();

        StringBuilder buffer = new StringBuilder(str);
        HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>(arrayList.size());
        String temp;
        for (int x = 0; x < arrayList.size(); x++) {
            temp = arrayList.get(x);
            int findIndexSize = 0;
            for (int start = -1; (start = buffer.indexOf(temp, findIndexSize)) > -1; ) {
                findIndexSize = start + temp.length();//从已找到的后面开始找
                Integer mapStart = hash.get(start);//起始位置  
                if (mapStart == null || (mapStart != null && findIndexSize > mapStart))//满足1个，即可更新map
                {
                    hash.put(start, findIndexSize);
                }
            }
        }
        Collection<Integer> values = hash.keySet();
        for (Integer startIndex : values) {
            Integer endIndex = hash.get(startIndex);
            buffer.replace(startIndex, endIndex, replaceAll.substring(0, endIndex - startIndex));
        }
        hash.clear();
        return buffer.toString();
    }

    /**
     * 初始化敏感词库
     */
    public static void InitializationWork() {
        replaceAll = new StringBuilder(replceSize);
        for (int x = 0; x < replceSize; x++) {
            replaceAll.append(replceStr);
        }
        //加载词库  
        arrayList = new ArrayList<String>();
        InputStreamReader read = null;
        BufferedReader bufferedReader = null;
        try {
            read = new InputStreamReader(SensitiveWordUtil.class.getClassLoader().getResourceAsStream(fileName), encoding);
            bufferedReader = new BufferedReader(read);
            for (String txt = null; (txt = bufferedReader.readLine()) != null; ) {
                if (!arrayList.contains(txt))
                    arrayList.add(txt);
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != bufferedReader)
                    bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != read)
                    read.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    //注：需更改 guaipai.pom ，编译打包时加载CensorWords.txt , 否则报 空指针异常
    public static void main(String[] args) {
        String str = "敏感词*****";
        str = SensitiveWordUtil.filterInfo(str);
        System.out.println("替换后的字符串为:\n" + str);
    }

}