DFA算法过滤敏感词，替换为*

1. import java.io.InputStream;  
2. import java.io.UnsupportedEncodingException;  
3. import java.nio.ByteBuffer;  
4. import java.util.ArrayList;  
5. import java.util.Enumeration;  
6. import java.util.List;  
7. import java.util.Properties;  
8.   
9. public class test {        
10.     /**  
11.      * 根节点  
12.      */    
13.     private TreeNode rootNode = new TreeNode();    
14.         
15.     /**  
16.      * 关键词缓存  
17.      */    
18.     private ByteBuffer keywordBuffer = ByteBuffer.allocate(1024);       
19.         
20.     /**  
21.      * 关键词编码  
22.      */    
23.     private String charset = "utf-8";    
24.     
25.     /**  
26.      * 建立DFA  
27.      * @param keywordList  
28.      * @throws UnsupportedEncodingException   
29.      */    
30.     public void createKeywordTree(List<String> keywordList) throws UnsupportedEncodingException{    
31.         for (String keyword : keywordList) {    
32.             if(keyword == null) continue;    
33.             keyword = keyword.trim();    
34.             byte[] bytes = keyword.getBytes(charset);    
35.             TreeNode tempNode = rootNode;    
36.             for (int i = 0; i < bytes.length; i++) {    
37.                 int index = bytes[i] & 0xff;     
38.                 TreeNode node = tempNode.getSubNode(index);    
39.                 if(node == null){    
40.                     node = new TreeNode();    
41.                     tempNode.setSubNode(index, node);    
42.                 }    
43.                 tempNode = node;    
44.                 if(i == bytes.length - 1){    
45.                     tempNode.setKeywordEnd(true);      
46.                 }    
47.             }    
48.         }  
49.     }    
50.         
51.      
52.     public String searchKeyword(String text) throws UnsupportedEncodingException{    
53.         return searchKeyword(text.getBytes(charset));    
54.     }    
55.      
56.     public String searchKeyword(byte[] bytes){    
57.         StringBuilder words = new StringBuilder();    
58.         if(bytes == null || bytes.length == 0){    
59.             return words.toString();    
60.         }    
61.         TreeNode tempNode = rootNode;    
62.         int rollback = 0;     
63.         int position = 0;   
64.         while (position < bytes.length) {    
65.             int index = bytes[position] & 0xFF;    
66.             keywordBuffer.put(bytes[position]);   
67.             tempNode = tempNode.getSubNode(index);    
68.             if(tempNode == null){  
69.                 position = position - rollback;  
70.                 rollback = 0;    
71.                 tempNode = rootNode;        
72.                 keywordBuffer.clear();    
73.             }    
74.             else if(tempNode.isKeywordEnd()){    
75.                 keywordBuffer.flip();    
76.                 for (int i = 0; i <= rollback; i++) {  
77.                         bytes[position-i] = 42;  
78.                 }  
79.                 keywordBuffer.limit(keywordBuffer.capacity());    
80.                 rollback = 1;    
81.             }else{     
82.                 rollback++;   
83.             }    
84.             position++;    
85.         }    
86.         String result = null;  
87.          try {  
88.              result  =  new String(bytes,"utf-8");    
89.               
90.         } catch (Exception e) {  
91.             e.printStackTrace();  
92.         }  
93.         return result;  
94.     }    
95.         
96.     public void setCharset(String charset) {    
97.         this.charset = charset;    
98.     }   
99. }  

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.List;  
3.   
4. public class TreeNode {    
5.     private static final int NODE_LEN = 256;    
6.         
7.     /**  
8.      * true 关键词的终结 ； false 继续  
9.      */    
10.     private boolean end = false;     
11.         
12.     private List<TreeNode> subNodes = new ArrayList<TreeNode>(NODE_LEN);    
13.         
14.     public TreeNode(){    
15.         for (int i = 0; i < NODE_LEN; i++) {    
16.             subNodes.add(i, null);    
17.         }    
18.     }    
19.         
20.     /**  
21.      * 向指定位置添加节点树  
22.      * @param index  
23.      * @param node  
24.      */    
25.     public void setSubNode(int index, TreeNode node){    
26.         subNodes.set(index, node);    
27.     }    
28.         
29.     public TreeNode getSubNode(int index){    
30.         return subNodes.get(index);    
31.     }    
32.         
33.     
34.     public boolean isKeywordEnd() {    
35.         return end;    
36.     }    
37.     
38.     public void setKeywordEnd(boolean end) {    
39.         this.end = end;    
40.     }    
41. }