Spring中过滤敏感词

此为实现过滤的.java文件，直接调用即可。

package Filter;

import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.Map;  
import java.util.Map.Entry; 

public class Filter {
    static int key_max = 0; // 敏感词最大长度  
    //static String[] keys ={"250,sb,cao,办证，发票"};  
    static ArrayList<String> first = new ArrayList<String>();  
    static String[] sortFirst;  
    static char[] charFirst;  
    static HashMap<String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>();  
    static HashMap<String, String[]> sortMap = new HashMap<String, String[]>();  
    static HashMap<String, char[]> charMap = new HashMap<String, char[]>();  
    static void init(String[] keys) {  
        ArrayList<String> temp;  
        String key, value;  
        int length;  
        for (String k : keys) {  
            if (!first.contains(k.substring(0, 1))) {  
                first.add(k.substring(0, 1));  
            }  
            length = k.length();  
            if (length > key_max) key_max = length;  
            for (int i = 1; i < length; i ++) {  
                key = k.substring(0, i);  
                value = k.substring(i, i + 1);  
                if (i == 1 && !first.contains(key)) {  
                    first.add(key);  
                }  
                  
                // 有，添加  
                if (map.containsKey(key)) {  
                    if (!map.get(key).contains(value)) {  
                        map.get(key).add(value);  
                    }  
                }  
                // 没有添加  
                else {  
                    temp = new ArrayList<String>();  
                    temp.add(value);  
                    map.put(key, temp);  
                }  
            }  
        }  
        sortFirst = first.toArray(new String[first.size()]);  
        Arrays.sort(sortFirst); // 排序  
          
        charFirst = new char[first.size()];  
        for (int i = 0; i < charFirst.length; i ++) {  
            charFirst[i] = first.get(i).charAt(0);  
        }  
        Arrays.sort(charFirst); // 排序  
          
        String[] sortValue;  
        ArrayList<String> v;  
        Map.Entry<String, ArrayList<String>> entry;  
        Iterator<Entry<String, ArrayList<String>>> iter = map.entrySet().iterator();  
        while (iter.hasNext()) {  
            entry = (Map.Entry<String, ArrayList<String>>) iter.next();  
            v = (ArrayList<String>)entry.getValue();  
            sortValue = v.toArray(new String[v.size()]);  
            Arrays.sort(sortValue); // 排序  
            sortMap.put(entry.getKey(), sortValue);  
        }  
          
        char[] charValue;  
        iter = map.entrySet().iterator();  
        while (iter.hasNext()) {  
            entry = (Map.Entry<String, ArrayList<String>>) iter.next();  
            v = (ArrayList<String>)entry.getValue();  
            charValue = new char[v.size()];  
            for (int i = 0; i < charValue.length; i ++) {  
                charValue[i] = v.get(i).charAt(0);  
            }  
            Arrays.sort(charValue);  // 排序  
            charMap.put(entry.getKey(), charValue);  
        }  
    }  
	
     /*
      实现过滤， 将敏感词替换为***
     */  
    public final static String filt(String content,String[] keyword)  //keyword为敏感词库，保存要屏蔽的敏感词
{  
        for (String k :keyword) {  
            content=content.replaceAll(k, "***"); 
        }  
        return content;  
    }  
      
}

           

<span style="font-size:18px;"><span style="white-space:pre">	</span>如果敏感词字间存在空格，仍需屏蔽，可以先对扫描的文件（即String content）调用String.replaceAll(" ","")函数。</span>