敏感詞、文字過濾是一個網站必不可少的功能，如何設計一個好的、高效的過濾演算法是非常有必要的。前段時間我一個朋友（馬上畢業，接觸程式設計不久）要我幫他看一個文字過濾的東西，它說檢索效率非常慢。我把它程式拿過來一看，整個過程如下：讀取敏感詞庫、如果HashSet集合中，獲取頁面上傳文字，然後進行匹配。我就想這個過程肯定是非常慢的。對於他這個沒有接觸的人來說我想也只能想到這個，更高階點就是正則表示式。但是非常遺憾，這兩種方法都是不可行的。當然，在我意識裡沒有我也沒有認知到那個演算法可以解決問題，但是Google知道！

        DFA簡介

在實現文字過濾的演算法中，DFA是唯一比較好的實現演算法。DFA即Deterministic Finite Automaton，也就是確定有窮自動機，它是是通過event和當前的state得到下一個state，即event+state=nextstate。下圖展示了其狀態的轉換

在這幅圖中大寫字母（S、U、V、Q）都是狀態，小寫字母a、b為動作。通過上圖我們可以看到如下關係

a b b
S —–> U S —–> V U —–> V

在實現敏感詞過濾的演算法中，我們必須要減少運算，而DFA在DFA演算法中幾乎沒有什麼計算，有的只是狀態的轉換。

         Java實現DFA演算法實現敏感詞過濾

在Java中實現敏感詞過濾的關鍵就是DFA演算法的實現。首先我們對上圖進行剖析。在這過程中我們認為下面這種結構會更加清晰明瞭。

同時這裡沒有狀態轉換，沒有動作，有的只是Query（查詢）。我們可以認為，通過S query U、V，通過U query V、P，通過V query U P。通過這樣的轉變我們可以將狀態的轉換轉變為使用Java集合的查詢。

誠然，加入在我們的敏感詞庫中存在如下幾個敏感詞：日本人、日本鬼子、毛.澤.東。那麼我需要構建成一個什麼樣的結構呢？

首先：query 日 —> {本}、query 本 —>{人、鬼子}、query 人 —>{null}、query 鬼 —> {子}。形如下結構：

下面我們在對這圖進行擴充套件：

這樣我們就將我們的敏感詞庫構建成了一個類似與一顆一顆的樹，這樣我們判斷一個詞是否為敏感詞時就大大減少了檢索的匹配範圍。比如我們要判斷日本人，根據第一個字我們就可以確認需要檢索的是那棵樹，然後再在這棵樹中進行檢索。

但是如何來判斷一個敏感詞已經結束了呢？利用標識位來判斷。

所以對於這個關鍵是如何來構建一棵棵這樣的敏感詞樹。下面我已Java中的HashMap為例來實現DFA演算法。具體過程如下：

日本人，日本鬼子為例

1、在hashMap中查詢“日”看其是否在hashMap中存在，如果不存在，則證明已“日”開頭的敏感詞還不存在，則我們直接構建這樣的一棵樹。跳至3。

2、如果在hashMap中查詢到了，表明存在以“日”開頭的敏感詞，設定hashMap = hashMap.get(“日”)，跳至1，依次匹配“本”、“人”。

3、判斷該字是否為該詞中的最後一個字。若是表示敏感詞結束，設定標誌位isEnd = 1，否則設定標誌位isEnd = 0；

程式實現如下：

1. /** 
2.      * 讀取敏感詞庫，將敏感詞放入HashSet中，構建一個DFA演算法模型：<br> 
3.      * 中 = { 
4.      *      isEnd = 0 
5.      *      國 = {<br> 
6.      *           isEnd = 1 
7.      *           人 = {isEnd = 0 
8.      *                民 = {isEnd = 1} 
9.      *                } 
10.      *           男  = { 
11.      *                  isEnd = 0 
12.      *                   人 = { 
13.      *                        isEnd = 1 
14.      *                       } 
15.      *               } 
16.      *           } 
17.      *      } 
18.      *  五 = { 
19.      *      isEnd = 0 
20.      *      星 = { 
21.      *          isEnd = 0 
22.      *          紅 = { 
23.      *              isEnd = 0 
24.      *              旗 = { 
25.      *                   isEnd = 1 
26.      *                  } 
27.      *              } 
28.      *          } 
29.      *      } 
30.      * @author chenming  
31.      * @date 2014年4月20日 下午3:04:20 
32.      * @param keyWordSet  敏感詞庫 
33.      * @version 1.0 
34.      */
35.     @SuppressWarnings({ “rawtypes”, “unchecked” })  
36.     privatevoid addSensitiveWordToHashMap(Set<String> keyWordSet) {  
37.         sensitiveWordMap = new HashMap(keyWordSet.size());     //初始化敏感詞容器，減少擴容操作
38.         String key = null;    
39.         Map nowMap = null;  
40.         Map<String, String> newWorMap = null;  
41.         //迭代keyWordSet
42.         Iterator<String> iterator = keyWordSet.iterator();  
43.         while(iterator.hasNext()){  
44.             key = iterator.next();    //關鍵字
45.             nowMap = sensitiveWordMap;  
46.             for(int i = 0 ; i < key.length() ; i++){  
47.                 char keyChar = key.charAt(i);       //轉換成char型
48.                 Object wordMap = nowMap.get(keyChar);       //獲取
49.                 if(wordMap != null){        //如果存在該key，直接賦值
50.                     nowMap = (Map) wordMap;  
51.                 }  
52.                 else{     //不存在則，則構建一個map，同時將isEnd設定為0，因為他不是最後一個
53.                     newWorMap = new HashMap<String,String>();  
54.                     newWorMap.put(”isEnd”, “0”);     //不是最後一個
55.                     nowMap.put(keyChar, newWorMap);  
56.                     nowMap = newWorMap;  
57.                 }  
58.                 if(i == key.length() - 1){  
59.                     nowMap.put(”isEnd”, “1”);    //最後一個
60.                 }  
61.             }  
62.         }  
63.     }  

/**
     * 讀取敏感詞庫，將敏感詞放入HashSet中，構建一個DFA演算法模型：<br>
     * 中 = {
     *      isEnd = 0
     *      國 = {<br>
     *           isEnd = 1
     *           人 = {isEnd = 0
     *                民 = {isEnd = 1}
     *                }
     *           男  = {
     *                  isEnd = 0
     *                   人 = {
     *                        isEnd = 1
     *                       }
     *               }
     *           }
     *      }
     *  五 = {
     *      isEnd = 0
     *      星 = {
     *          isEnd = 0
     *          紅 = {
     *              isEnd = 0
     *              旗 = {
     *                   isEnd = 1
     *                  }
     *              }
     *          }
     *      }
     * @author chenming 
     * @date 2014年4月20日 下午3:04:20
     * @param keyWordSet  敏感詞庫
     * @version 1.0
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    private void addSensitiveWordToHashMap(Set<String> keyWordSet) {
        sensitiveWordMap = new HashMap(keyWordSet.size());     //初始化敏感詞容器，減少擴容操作
        String key = null;  
        Map nowMap = null;
        Map<String, String> newWorMap = null;
        //迭代keyWordSet
        Iterator<String> iterator = keyWordSet.iterator();
        while(iterator.hasNext()){
            key = iterator.next();    //關鍵字
            nowMap = sensitiveWordMap;
            for(int i = 0 ; i < key.length() ; i++){
                char keyChar = key.charAt(i);       //轉換成char型
                Object wordMap = nowMap.get(keyChar);       //獲取

                if(wordMap != null){        //如果存在該key，直接賦值
                    nowMap = (Map) wordMap;
                }
                else{     //不存在則，則構建一個map，同時將isEnd設定為0，因為他不是最後一個
                    newWorMap = new HashMap<String,String>();
                    newWorMap.put("isEnd", "0");     //不是最後一個
                    nowMap.put(keyChar, newWorMap);
                    nowMap = newWorMap;
                }

                if(i == key.length() - 1){
                    nowMap.put("isEnd", "1");    //最後一個
                }
            }
        }
    }

執行得到的hashMap結構如下：

{五={星={紅={isEnd=0, 旗={isEnd=1}}, isEnd=0}, isEnd=0}, 中={isEnd=0, 國={isEnd=0, 人={isEnd=1}, 男={isEnd=0, 人={isEnd=1}}}}}

敏感詞庫我們一個簡單的方法給實現了，那麼如何實現檢索呢？檢索過程無非就是hashMap的get實現，找到就證明該詞為敏感詞，否則不為敏感詞。過程如下：假如我們匹配“中國人民萬歲”。

1、第一個字“中”，我們在hashMap中可以找到。得到一個新的map = hashMap.get(“”)。

2、如果map == null，則不是敏感詞。否則跳至3

3、獲取map中的isEnd，通過isEnd是否等於1來判斷該詞是否為最後一個。如果isEnd == 1表示該詞為敏感詞，否則跳至1。

通過這個步驟我們可以判斷“中國人民”為敏感詞，但是如果我們輸入“中國女人”則不是敏感詞了。

1. /** 
2.      * 檢查文字中是否包含敏感字元，檢查規則如下：<br> 
3.      * @author chenming  
4.      * @date 2014年4月20日 下午4:31:03 
5.      * @param txt 
6.      * @param beginIndex 
7.      * @param matchType 
8.      * @return，如果存在，則返回敏感詞字元的長度，不存在返回0 
9.      * @version 1.0 
10.      */
11.     @SuppressWarnings({ “rawtypes”})  
12.     publicint CheckSensitiveWord(String txt,int beginIndex,int matchType){  
13.         boolean  flag = false;    //敏感詞結束標識位：用於敏感詞只有1位的情況
14.         int matchFlag = 0;     //匹配標識數預設為0
15.         char word = 0;  
16.         Map nowMap = sensitiveWordMap;  
17.         for(int i = beginIndex; i < txt.length() ; i++){  
18.             word = txt.charAt(i);  
19.             nowMap = (Map) nowMap.get(word);     //獲取指定key
20.             if(nowMap != null){     //存在，則判斷是否為最後一個
21.                 matchFlag++;     //找到相應key，匹配標識+1 
22.                 if(“1”.equals(nowMap.get(“isEnd”))){       //如果為最後一個匹配規則,結束迴圈，返回匹配標識數
23.                     flag = true;       //結束標誌位為true   
24.                     if(SensitivewordFilter.minMatchTYpe == matchType){    //最小規則，直接返回,最大規則還需繼續查詢
25.                         break;  
26.                     }  
27.                 }  
28.             }  
29.             else{     //不存在，直接返回
30.                 break;  
31.             }  
32.         }  
33.         if(matchFlag < 2 && !flag){       
34.             matchFlag = 0;  
35.         }  
36.         return matchFlag;  
37.     }  

/**
     * 檢查文字中是否包含敏感字元，檢查規則如下：<br>
     * @author chenming 
     * @date 2014年4月20日 下午4:31:03
     * @param txt
     * @param beginIndex
     * @param matchType
     * @return，如果存在，則返回敏感詞字元的長度，不存在返回0
     * @version 1.0
     */
    @SuppressWarnings({ "rawtypes"})
    public int CheckSensitiveWord(String txt,int beginIndex,int matchType){
        boolean  flag = false;    //敏感詞結束標識位：用於敏感詞只有1位的情況
        int matchFlag = 0;     //匹配標識數預設為0
        char word = 0;
        Map nowMap = sensitiveWordMap;
        for(int i = beginIndex; i < txt.length() ; i++){
            word = txt.charAt(i);
            nowMap = (Map) nowMap.get(word);     //獲取指定key
            if(nowMap != null){     //存在，則判斷是否為最後一個
                matchFlag++;     //找到相應key，匹配標識+1 
                if("1".equals(nowMap.get("isEnd"))){       //如果為最後一個匹配規則,結束迴圈，返回匹配標識數
                    flag = true;       //結束標誌位為true   
                    if(SensitivewordFilter.minMatchTYpe == matchType){    //最小規則，直接返回,最大規則還需繼續查詢
                        break;
                    }
                }
            }
            else{     //不存在，直接返回
                break;
            }
        }
        if(matchFlag < 2 && !flag){     
            matchFlag = 0;
        }
        return matchFlag;
    }

在文章末尾我提供了利用Java實現敏感詞過濾的檔案下載。下面是一個測試類來證明這個演算法的效率和可靠性。

1. publicstaticvoid main(String[] args) {  
2.         SensitivewordFilter filter = new SensitivewordFilter();  
3.         System.out.println(”敏感詞的數量：” + filter.sensitiveWordMap.size());  
4.         String string = ”太多的傷感情懷也許只侷限於飼養基地 熒幕中的情節，主人公嘗試著去用某種方式漸漸的很瀟灑地釋自殺指南懷那些自己經歷的傷感。”
5.                         + ”然後法.輪.功 我們的扮演的角色就是跟隨著主人公的喜紅客聯盟 怒哀樂而過於牽強的把自己的情感也附加於銀幕情節中，然後感動就流淚，”
6.                         + ”難過就躺在某一個人的懷裡盡情的闡述心扉或者手機卡複製器一個人一杯紅酒一部電影在夜三.級.片 深人靜的晚上，關上電話靜靜的發呆著。”;  
7.         System.out.println(”待檢測語句字數：” + string.length());  
8.         long beginTime = System.currentTimeMillis();  
9.         Set<String> set = filter.getSensitiveWord(string, 1);  
10.         long endTime = System.currentTimeMillis();  
11.         System.out.println(”語句中包含敏感詞的個數為：” + set.size() + “。包含：” + set);  
12.         System.out.println(”總共消耗時間為：” + (endTime - beginTime));  
13.     }  

public static void main(String[] args) {
        SensitivewordFilter filter = new SensitivewordFilter();
        System.out.println("敏感詞的數量：" + filter.sensitiveWordMap.size());
        String string = "太多的傷感情懷也許只侷限於飼養基地 熒幕中的情節，主人公嘗試著去用某種方式漸漸的很瀟灑地釋自殺指南懷那些自己經歷的傷感。"
                        + "然後法.輪.功 我們的扮演的角色就是跟隨著主人公的喜紅客聯盟 怒哀樂而過於牽強的把自己的情感也附加於銀幕情節中，然後感動就流淚，"
                        + "難過就躺在某一個人的懷裡盡情的闡述心扉或者手機卡複製器一個人一杯紅酒一部電影在夜三.級.片 深人靜的晚上，關上電話靜靜的發呆著。";
        System.out.println("待檢測語句字數：" + string.length());
        long beginTime = System.currentTimeMillis();
        Set<String> set = filter.getSensitiveWord(string, 1);
        long endTime = System.currentTimeMillis();
        System.out.println("語句中包含敏感詞的個數為：" + set.size() + "。包含：" + set);
        System.out.println("總共消耗時間為：" + (endTime - beginTime));
    }

執行結果：

從上面的結果可以看出，敏感詞庫有771個，檢測語句長度為184個字元，查出6個敏感詞。總共耗時1毫秒。可見速度還是非常可觀的。

下面提供兩個文件下載：

Desktop.rar（http://pan.baidu.com/s/1o66teGU）裡面包含兩個Java檔案，一個是讀取敏感詞庫（SensitiveWordInit），一個是敏感詞工具類（SensitivewordFilter），裡面包含了判斷是否存在敏感詞（isContaintSensitiveWord(String txt,int matchType)）、獲取敏感詞（getSensitiveWord(String txt , int matchType)）、敏感詞替代（replaceSensitiveWord(String txt,int matchType,String replaceChar)）三個方法。

——————————————————————————————————————————————————–

–                                  –

–                                                                                                                 –
——————————————————————————————————————————————————–