您的位置: 首页  >  文章  >  敏感词过滤-DFA算法

敏感词过滤-DFA算法

分类: 文章 • 2025-02-27 09:58:29

目录

DFA算法简介

Java实现DFA算法实现敏感词过滤

测试方法

创建DFAMap

根据DFAMap进行检验

完整代码

DFA算法简介

在实现文字过滤的算法中，DFA是唯一比较好的实现算法。DFA即Deterministic Finite Automaton，也就是确定有穷自动机，它是是通过event和当前的state得到下一个state，即event+state=nextstate。下图展示了其状态的转换

敏感词过滤-DFA算法

在这幅图中大写字母（S、U、V、Q）都是状态，小写字母a、b为动作。通过上图我们可以看到如下关系

在实现敏感词过滤的算法中，我们必须要减少运算，而DFA在DFA算法中几乎没有什么计算，有的只是状态的转换。

Java实现DFA算法实现敏感词过滤

测试方法

package algorithm.string.dfa;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Main {

	public static void main(String[] args) {

		Set<String> set=new HashSet<>();
		set.add("大中华");
		set.add("大中华帝国");
		set.add("大汉民族");
		set.add("日本人");
		set.add("日本鬼子");
		
		DFAUtil dfa=new DFAUtil();
		dfa.createDFAHashMap(set);
		Set<String> result=dfa.getSensitiveWordByDFAMap("大中华帝国和日本人",1);
		System.out.println("敏感词有"+result.size()+"个");
		for(String string:result){
			System.out.println("违背敏感词："+string);
		}
		
		
	}

}

创建DFAMap

         在Java中实现敏感词过滤的关键就是DFA算法的实现。首先我们对上图进行剖析。在这过程中我们认为下面这种结构会更加清晰明了。

敏感词过滤-DFA算法

 

         同时这里没有状态转换，没有动作，有的只是Query（查找）。我们可以认为，通过S query U、V，通过U query V、P，通过V query U P。通过这样的转变我们可以将状态的转换转变为使用Java集合的查找。

诚然，加入在我们的敏感词库中存在如下几个敏感词：日本人、日本鬼子、毛.泽.东。那么我需要构建成一个什么样的结构呢？

首先：query 日 ---> {本}、query 本 --->{人、鬼子}、query 人 --->{null}、query 鬼 ---> {子}。形如下结构：

敏感词过滤-DFA算法

 

         下面我们在对这图进行扩展：

敏感词过滤-DFA算法

 

         这样我们就将我们的敏感词库构建成了一个类似与一颗一颗的树，这样我们判断一个词是否为敏感词时就大大减少了检索的匹配范围。比如我们要判断日本人，根据第一个字我们就可以确认需要检索的是那棵树，然后再在这棵树中进行检索。

         但是如何来判断一个敏感词已经结束了呢？利用标识位来判断。

         所以对于这个关键是如何来构建一棵棵这样的敏感词树。下面我已Java中的HashMap为例来实现DFA算法。具体过程如下：

日本人，日本鬼子为例

         1、在hashMap中查询“日”看其是否在hashMap中存在，如果不存在，则证明已“日”开头的敏感词还不存在，则我们直接构建这样的一棵树。跳至3。

         2、如果在hashMap中查找到了，表明存在以“日”开头的敏感词，设置hashMap = hashMap.get("日")，跳至1，依次匹配“本”、“人”。

         3、判断该字是否为该词中的最后一个字。若是表示敏感词结束，设置标志位isEnd = 1，否则设置标志位isEnd = 0；

敏感词过滤-DFA算法

程序实现如下：

注意：本文的编写和代码的编写参考了https://blog.****.net/chenssy/article/details/26961957

但是在代码上对它进行了改进，修复了几个bug

	/*{日=
	 * 	{本=
	 * 		{人={isEnd=1}, 
	 * 		鬼=
	 * 			{子={isEnd=1}, 
	 * 			isEnd=0}, 
	 * 		isEnd=0}, 
	 * 	isEnd=0}, 
	 * 
	 * 大=
	 * 	{汉=
	 * 		{民={isEnd=0, 
	 * 			族={isEnd=1}}, 
	 * 		isEnd=0}, 
	 * 	isEnd=0, 
	 * 	中={isEnd=0, 
	 * 		华={isEnd=1, 
	 * 			帝={isEnd=0, 
	 * 				国={isEnd=1}}}}}}*/

/**set作为敏感词，创建出对应的dfa的Map，以供检验敏感词
	 * @param set
	 */
	public void createDFAHashMap(Set<String> set){
		HashMap<String, Object> nowMap;
		//根据set的大小，创建map的大小
		dfaMap=new HashMap<>(set.size());
		//对set里的字符串进行循环
		for(String key:set){
			//对每个字符串最初，nowMap就是dfaMap
			nowMap=dfaMap;			
			for(int i=0;i<key.length();i++){
				//一个个字符循环
				String nowChar=String.valueOf(key.charAt(i));
				//根据nowChar得到nowMap里面对应的value
				HashMap<String, Object> map=(HashMap<String, Object>)nowMap.get(nowChar);
				//如果map为空，则说明nowMap里面没有以nowChar开头的东西，则创建一个新的hashmap，
				//以nowChar为key，新的map为value，放入nowMap
				if(map==null){
					map=new HashMap<String,Object>();
					nowMap.put(nowChar, map);
				}		
				//nowMap=map，就是nowChar对应的对象
				nowMap=map;
				//最后在nowMap里设置isEnd
				//如果nowMap里面已经有isEnd，并且为1，说明以前已经有关键字了，就不再设置isEnd
				//因为如果没有这一步，大中华和大中华帝国，先设置大中华
				//在大中华帝国设置的时候，华对应的map有isEnd=1，如果这时对它覆盖，就会isEnd=0，导致大中华这个关键字失效
				if(nowMap.containsKey("isEnd")&&nowMap.get("isEnd").equals("1")){
					continue;
				}				
				if(i!=key.length()-1){
					nowMap.put("isEnd", "0");
				}
				else{
					nowMap.put("isEnd", "1");
				}								
			}						
		}
		System.out.println(dfaMap);
	}

得到的结果是

{日={本={人={isEnd=1}, 鬼={子={isEnd=1}, isEnd=0}, isEnd=0}, isEnd=0}, 大={汉={民={isEnd=0, 族={isEnd=1}}, isEnd=0}, isEnd=0, 中={isEnd=0, 华={isEnd=1, 帝={isEnd=0, 国={isEnd=1}}}}}}
具体可以看上面的注释

根据DFAMap进行检验

   敏感词库我们一个简单的方法给实现了，那么如何实现检索呢？检索过程无非就是hashMap的get实现，找到就证明该词为敏感词，否则不为敏感词。过程如下：假如我们匹配“中国人民万岁”。

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

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

 3、获取map中的isEnd，通过isEnd是否等于1来判断该词是否为最后一个。如果isEnd == 1表示该词为敏感词，更新resultLength否则跳至1。

 通过这个步骤我们可以判断“中国人民”为敏感词，但是如果我们输入“中国女人”则不是敏感词了。
 

        HashMap<String, Object> dfaMap;
	
	public static final int minMatchType=1;
	
	public static final int maxMatchType=2;

	/** 用创建的dfaMap，根据matchType检验字符串string是否包含敏感词，返回包含所有对于敏感词的set
	 * @param string 要检查是否有敏感词在内的字符串
	 * @param matchType 检查类型，如大中华帝国牛逼对应大中华和大中华帝国两个关键字，1为最小检查，会检查出大中华，2位最大，会检查出大中华帝国	
	 * @return
	 */
	public Set<String> getSensitiveWordByDFAMap(String string,int matchType){
		Set<String> set=new HashSet<>();
		for(int i=0;i<string.length();i++){
			//matchType是针对同一个begin的后面，在同一个begin匹配最长的还是最短的敏感词
			int length=getSensitiveLengthByDFAMap(string,i,matchType);
			if(length>0){
				set.add(string.substring(i,i+length));
				//这个对应的是一个敏感词内部的关键字（不包括首部），如果加上，大中华帝国，对应大中华和中华两个敏感词，只会对应大中华而不是两个
				//i=i+length-1;//减1的原因，是因为for会自增
			}
		}		
		return set;
	}
	
	/**如果存在，则返回敏感词字符的长度，不存在返回0
	 * @param string
	 * @param beginIndex
	 * @param matchType  1：最小匹配规则，2：最大匹配规则
	 * @return
	 */
	public int getSensitiveLengthByDFAMap(String string,int beginIndex,int matchType){
		//当前匹配的长度
		int nowLength=0;
		//最终匹配敏感词的长度，因为匹配规则2，如果大中华帝，对应大中华，大中华帝国，在华的时候，nowLength=3，因为是最后一个字，将nowLenth赋给resultLength
		//然后在帝的时候，now=4，result=3，然后不匹配，resultLength就是上一次最大匹配的敏感词的长度
		int resultLength=0;
		HashMap<String, Object> nowMap=dfaMap;
		for(int i=beginIndex;i<string.length();i++){
			String nowChar=String.valueOf(string.charAt(i));
			//根据nowChar得到对应的map，并赋值给nowMap
			nowMap=(HashMap<String, Object>)nowMap.get(nowChar);
			//nowMap里面没有这个char，说明不匹配，直接返回
			if(nowMap==null){
				break;
			}
			else{
				nowLength++;
				//如果现在是最后一个，更新resultLength
				if("1".equals(nowMap.get("isEnd"))){
					resultLength=nowLength;
					//如果匹配模式是最小，直接匹配到，退出
					//匹配模式是最大，则继续匹配，resultLength保留上一次匹配到的length
					if(matchType==minMatchType){
						break;
					}
				}
			}
		}		
		return resultLength;
	}

这里的改进是

取消了i的直接增加

				//这个对应的是一个敏感词内部的关键字（不包括首部），如果加上，大中华帝国，对应大中华和中华两个敏感词，只会对应大中华而不是两个
				//i=i+length-1;//减1的原因，是因为for会自增

加入了resultLength

		//最终匹配敏感词的长度，因为匹配规则2，如果大中华帝，对应大中华，大中华帝国，在华的时候，nowLength=3，因为是最后一个字，将nowLenth赋给resultLength
		//然后在帝的时候，now=4，result=3，然后不匹配，resultLength就是上一次最大匹配的敏感词的长度
		int resultLength=0;

这里面字符串为 大中华帝国和日本人

如果最小匹配，对应

敏感词有2个
违背敏感词：大中华
违背敏感词：日本人

最大匹配，对应

敏感词有2个
违背敏感词：大中华帝国
违背敏感词：日本人

完整代码

package algorithm.string.dfa;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DFAUtil {
	
	HashMap<String, Object> dfaMap;
	
	public static final int minMatchType=1;
	
	public static final int maxMatchType=2;
	
	/*{日=
	 * 	{本=
	 * 		{人={isEnd=1}, 
	 * 		鬼=
	 * 			{子={isEnd=1}, 
	 * 			isEnd=0}, 
	 * 		isEnd=0}, 
	 * 	isEnd=0}, 
	 * 
	 * 大=
	 * 	{汉=
	 * 		{民={isEnd=0, 
	 * 			族={isEnd=1}}, 
	 * 		isEnd=0}, 
	 * 	isEnd=0, 
	 * 	中={isEnd=0, 
	 * 		华={isEnd=1, 
	 * 			帝={isEnd=0, 
	 * 				国={isEnd=1}}}}}}*/	
	/**set作为敏感词，创建出对应的dfa的Map，以供检验敏感词
	 * @param set
	 */
	public void createDFAHashMap(Set<String> set){
		HashMap<String, Object> nowMap;
		//根据set的大小，创建map的大小
		dfaMap=new HashMap<>(set.size());
		//对set里的字符串进行循环
		for(String key:set){
			//对每个字符串最初，nowMap就是dfaMap
			nowMap=dfaMap;			
			for(int i=0;i<key.length();i++){
				//一个个字符循环
				String nowChar=String.valueOf(key.charAt(i));
				//根据nowChar得到nowMap里面对应的value
				HashMap<String, Object> map=(HashMap<String, Object>)nowMap.get(nowChar);
				//如果map为空，则说明nowMap里面没有以nowChar开头的东西，则创建一个新的hashmap，
				//以nowChar为key，新的map为value，放入nowMap
				if(map==null){
					map=new HashMap<String,Object>();
					nowMap.put(nowChar, map);
				}		
				//nowMap=map，就是nowChar对应的对象
				nowMap=map;
				//最后在nowMap里设置isEnd
				//如果nowMap里面已经有isEnd，并且为1，说明以前已经有关键字了，就不再设置isEnd
				//因为如果没有这一步，大中华和大中华帝国，先设置大中华
				//在大中华帝国设置的时候，华对应的map有isEnd=1，如果这时对它覆盖，就会isEnd=0，导致大中华这个关键字失效
				if(nowMap.containsKey("isEnd")&&nowMap.get("isEnd").equals("1")){
					continue;
				}				
				if(i!=key.length()-1){
					nowMap.put("isEnd", "0");
				}
				else{
					nowMap.put("isEnd", "1");
				}								
			}						
		}
		System.out.println(dfaMap);
	}
	
	
	/** 用创建的dfaMap，根据matchType检验字符串string是否包含敏感词，返回包含所有对于敏感词的set
	 * @param string 要检查是否有敏感词在内的字符串
	 * @param matchType 检查类型，如大中华帝国牛逼对应大中华和大中华帝国两个关键字，1为最小检查，会检查出大中华，2位最大，会检查出大中华帝国	
	 * @return
	 */
	public Set<String> getSensitiveWordByDFAMap(String string,int matchType){
		Set<String> set=new HashSet<>();
		for(int i=0;i<string.length();i++){
			//matchType是针对同一个begin的后面，在同一个begin匹配最长的还是最短的敏感词
			int length=getSensitiveLengthByDFAMap(string,i,matchType);
			if(length>0){
				set.add(string.substring(i,i+length));
				//这个对应的是一个敏感词内部的关键字（不包括首部），如果加上，大中华帝国，对应大中华和中华两个敏感词，只会对应大中华而不是两个
				//i=i+length-1;//减1的原因，是因为for会自增
			}
		}		
		return set;
	}
	
	/**如果存在，则返回敏感词字符的长度，不存在返回0
	 * @param string
	 * @param beginIndex
	 * @param matchType  1：最小匹配规则，2：最大匹配规则
	 * @return
	 */
	public int getSensitiveLengthByDFAMap(String string,int beginIndex,int matchType){
		//当前匹配的长度
		int nowLength=0;
		//最终匹配敏感词的长度，因为匹配规则2，如果大中华帝，对应大中华，大中华帝国，在华的时候，nowLength=3，因为是最后一个字，将nowLenth赋给resultLength
		//然后在帝的时候，now=4，result=3，然后不匹配，resultLength就是上一次最大匹配的敏感词的长度
		int resultLength=0;
		HashMap<String, Object> nowMap=dfaMap;
		for(int i=beginIndex;i<string.length();i++){
			String nowChar=String.valueOf(string.charAt(i));
			//根据nowChar得到对应的map，并赋值给nowMap
			nowMap=(HashMap<String, Object>)nowMap.get(nowChar);
			//nowMap里面没有这个char，说明不匹配，直接返回
			if(nowMap==null){
				break;
			}
			else{
				nowLength++;
				//如果现在是最后一个，更新resultLength
				if("1".equals(nowMap.get("isEnd"))){
					resultLength=nowLength;
					//如果匹配模式是最小，直接匹配到，退出
					//匹配模式是最大，则继续匹配，resultLength保留上一次匹配到的length
					if(matchType==minMatchType){
						break;
					}
				}
			}
		}		
		return resultLength;
	}
}

 

与前缀树的类似与不同

前缀树总结

https://blog.****.net/xushiyu1996818/article/details/89354425


类似

思路类似，都是一个个节点，每个节点包含通往下一群节点的容器。


不同

前缀树：

这种java实现的下一个节点的容器是new TreeNode[26]，同时还有path（经过这个节点的数量），end（以这个节点结尾的数量），倾向于查找字符串的个数和前缀的个数

dfa：

java实现的容器是Map<String,Object>，没有path，只有key=isEnd，倾向于查询这个字符串中是否包含敏感词

 

其实两者本来是一个源头，只是为了不同的目的，从而node的构造不同
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

相关推荐