DFA,即Deterministic Finite Automaton,也就是确定有穷自动机。
读音:
[dɪˌtɜːmɪˈnɪstɪk] [ˈfaɪˌnaɪt] [ɔˈtɑmətən, -ˌtɑn]
具体可以参考:http://www.mamicode.com/info-detail-965728.html
比如我们有爱恋、哈哈、感动、静静、发呆、太多、啦啦这几个敏感词,以上其实是通过HashMap组织成的树形结构,比如我们通过“太”就可以知道这个字是否是“太多”这个词的最后一个字,并且可以通过“太”获取到“多”这个字且知道其是否为最后一个字。通过这些信息我们就可以过滤掉敏感词汇。
java例子:
package com.admin.util;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* 敏感词处理 - DFA算法实现
*
* @author jeff
* @since 2018/3/15
*/
public class SensitiveWordUtil {
/**
* 敏感词匹配规则
*/
public static final int MinMatchTYpe = 1; //最小匹配规则,如:敏感词库["中国","中国人"],语句:"我是中国人",匹配结果:我是[中国]人
public static final int MaxMatchType = 2; //最大匹配规则,如:敏感词库["中国","中国人"],语句:"我是中国人",匹配结果:我是[中国人]
/**
* 敏感词集合
*/
public static HashMap sensitiveWordMap;
/**
* 初始化敏感词库,构建DFA算法模型
*
* @param sensitiveWordSet 敏感词库
*/
public static synchronized void init(Set<String> sensitiveWordSet) {
initSensitiveWordMap(sensitiveWordSet);
}
/**
* 初始化敏感词库,构建DFA算法模型
*
* @param sensitiveWordSet 敏感词库
*/
private static void initSensitiveWordMap(Set<String> sensitiveWordSet) {
//初始化敏感词容器,减少扩容操作
sensitiveWordMap = new HashMap(sensitiveWordSet.size());
String key;
Map nowMap;
Map<String, String> newWorMap;
//迭代sensitiveWordSet
Iterator<String> iterator = sensitiveWordSet.iterator();
while (iterator.hasNext()) {
//关键字
key = iterator.next();
nowMap = sensitiveWordMap;
for (int i = 0; i < key.length(); i++) {
//转换成char型
char keyChar = key.charAt(i);
//库中获取关键字
Object wordMap = nowMap.get(keyChar);
//如果存在该key,直接赋值,用于下一个循环获取
if (wordMap != null) {
nowMap = (Map) wordMap;
} else {
//不存在则,则构建一个map,同时将isEnd设置为0,因为他不是最后一个
newWorMap = new HashMap<>();
//不是最后一个
newWorMap.put("isEnd", "0");
nowMap.put(keyChar, newWorMap);
nowMap = newWorMap;
}
if (i == key.length() - 1) {
//最后一个
nowMap.put("isEnd", "1");
}
}
}
}
/**
* 判断文字是否包含敏感字符
*
* @param txt 文字
* @param matchType 匹配规则 1:最小匹配规则,2:最大匹配规则
* @return 若包含返回true,否则返回false
*/
public static boolean contains(String txt, int matchType) {
boolean flag = false;
for (int i = 0; i < txt.length(); i++) {
int matchFlag = checkSensitiveWord(txt, i, matchType); //判断是否包含敏感字符
if (matchFlag > 0) { //大于0存在,返回true
flag = true;
}
}
return flag;
}
/**
* 判断文字是否包含敏感字符
*
* @param txt 文字
* @return 若包含返回true,否则返回false
*/
public static boolean contains(String txt) {
return contains(txt, MaxMatchType);
}
/**
* 获取文字中的敏感词
*
* @param txt 文字
* @param matchType 匹配规则 1:最小匹配规则,2:最大匹配规则
* @return
*/
public static Set<String> getSensitiveWord(String txt, int matchType) {
Set<String> sensitiveWordList = new HashSet<>();
for (int i = 0; i < txt.length(); i++) {
//判断是否包含敏感字符
int length = checkSensitiveWord(txt, i, matchType);
if (length > 0) {//存在,加入list中
sensitiveWordList.add(txt.substring(i, i + length));
i = i + length - 1;//减1的原因,是因为for会自增
}
}
return sensitiveWordList;
}
/**
* 获取文字中的敏感词
*
* @param txt 文字
* @return
*/
public static Set<String> getSensitiveWord(String txt) {
return getSensitiveWord(txt, MaxMatchType);
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceChar 替换的字符,匹配的敏感词以字符逐个替换,如 语句:我爱中国人 敏感词:中国人,替换字符:*, 替换结果:我爱***
* @param matchType 敏感词匹配规则
* @return
*/
public static String replaceSensitiveWord(String txt, char replaceChar, int matchType) {
String resultTxt = txt;
//获取所有的敏感词
Set<String> set = getSensitiveWord(txt, matchType);
Iterator<String> iterator = set.iterator();
String word;
String replaceString;
while (iterator.hasNext()) {
word = iterator.next();
replaceString = getReplaceChars(replaceChar, word.length());
resultTxt = resultTxt.replaceAll(word, replaceString);
}
return resultTxt;
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceChar 替换的字符,匹配的敏感词以字符逐个替换,如 语句:我爱中国人 敏感词:中国人,替换字符:*, 替换结果:我爱***
* @return
*/
public static String replaceSensitiveWord(String txt, char replaceChar) {
return replaceSensitiveWord(txt, replaceChar, MaxMatchType);
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceStr 替换的字符串,匹配的敏感词以字符逐个替换,如 语句:我爱中国人 敏感词:中国人,替换字符串:[屏蔽],替换结果:我爱[屏蔽]
* @param matchType 敏感词匹配规则
* @return
*/
public static String replaceSensitiveWord(String txt, String replaceStr, int matchType) {
String resultTxt = txt;
//获取所有的敏感词
Set<String> set = getSensitiveWord(txt, matchType);
Iterator<String> iterator = set.iterator();
String word;
while (iterator.hasNext()) {
word = iterator.next();
resultTxt = resultTxt.replaceAll(word, replaceStr);
}
return resultTxt;
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceStr 替换的字符串,匹配的敏感词以字符逐个替换,如 语句:我爱中国人 敏感词:中国人,替换字符串:[屏蔽],替换结果:我爱[屏蔽]
* @return
*/
public static String replaceSensitiveWord(String txt, String replaceStr) {
return replaceSensitiveWord(txt, replaceStr, MaxMatchType);
}
/**
* 获取替换字符串
*
* @param replaceChar
* @param length
* @return
*/
private static String getReplaceChars(char replaceChar, int length) {
String resultReplace = String.valueOf(replaceChar);
for (int i = 1; i < length; i++) {
resultReplace += replaceChar;
}
return resultReplace;
}
/**
* 检查文字中是否包含敏感字符,检查规则如下:<br>
*
* @param txt
* @param beginIndex
* @param matchType
* @return 如果存在,则返回敏感词字符的长度,不存在返回0
*/
private static int checkSensitiveWord(String txt, int beginIndex, int matchType) {
//敏感词结束标识位:用于敏感词只有1位的情况
boolean flag = false;
//匹配标识数默认为0
int matchFlag = 0;
char word;
Map nowMap = sensitiveWordMap;
for (int i = beginIndex; i < txt.length(); i++) {
word = txt.charAt(i);
//获取指定key
nowMap = (Map) nowMap.get(word);
if (nowMap != null) {//存在,则判断是否为最后一个
//找到相应key,匹配标识+1
matchFlag++;
//如果为最后一个匹配规则,结束循环,返回匹配标识数
if ("1".equals(nowMap.get("isEnd"))) {
//结束标志位为true
flag = true;
//最小规则,直接返回,最大规则还需继续查找
if (MinMatchType == matchType) {
break;
}
}
} else {//不存在,直接返回
break;
}
}
if (matchFlag < 2 || !flag) {//长度必须大于等于1,为词
matchFlag = 0;
}
return matchFlag;
}
public static void main(String[] args) {
Set<String> sensitiveWordSet = new HashSet<>();
sensitiveWordSet.add("共和国");
sensitiveWordSet.add("共产");
sensitiveWordSet.add("政府");
sensitiveWordSet.add("万万岁");
sensitiveWordSet.add("万岁");
//初始化敏感词库
SensitiveWordUtil.init(sensitiveWordSet);
System.out.println("敏感词的数量:" + SensitiveWordUtil.sensitiveWordMap.size());
String string = "中华人民共和国万岁,伟大的共产党万岁,中央人民政府万岁。万岁万岁万万岁。";
System.out.println("待检测语句字数:" + string.length());
//是否含有关键字
boolean result = SensitiveWordUtil.contains(string);
System.out.println(result);
result = SensitiveWordUtil.contains(string, SensitiveWordUtil.MaxMatchType);
System.out.println(result);
//获取语句中的敏感词
Set<String> set = SensitiveWordUtil.getSensitiveWord(string);
System.out.println("语句中包含敏感词的个数为:" + set.size() + "。包含:" + set);
set = SensitiveWordUtil.getSensitiveWord(string, SensitiveWordUtil.MaxMatchType);
System.out.println("语句中包含敏感词的个数为:" + set.size() + "。包含:" + set);
//替换语句中的敏感词
String filterStr = SensitiveWordUtil.replaceSensitiveWord(string, '*');
System.out.println(filterStr);
filterStr = SensitiveWordUtil.replaceSensitiveWord(string, '*', SensitiveWordUtil.MaxMatchType);
System.out.println(filterStr);
String filterStr2 = SensitiveWordUtil.replaceSensitiveWord(string, "[*敏感词*]");
System.out.println(filterStr2);
filterStr2 = SensitiveWordUtil.replaceSensitiveWord(string, "[*敏感词*]", SensitiveWordUtil.MaxMatchType);
System.out.println(filterStr2);
}
}
打印结果:
敏感词的数量:3
待检测语句字数:36
true
true
语句中包含敏感词的个数为:5。包含:[万岁, 万万岁, 共和国, 政府, 共产]
语句中包含敏感词的个数为:5。包含:[万岁, 万万岁, 共和国, 政府, 共产]
中华人民*****,伟大的**党**,中央人民****。****万**。
中华人民*****,伟大的**党**,中央人民****。****万**。
中华人民[*敏感词*][*敏感词*],伟大的[*敏感词*]党[*敏感词*],中央人民[*敏感词*][*敏感词*]。[*敏感词*][*敏感词*]万[*敏感词*]。
中华人民[*敏感词*][*敏感词*],伟大的[*敏感词*]党[*敏感词*],中央人民[*敏感词*][*敏感词*]。[*敏感词*][*敏感词*]万[*敏感词*]。
最大匹配原则验证:
{
你={isEnd=0,
好={
啊={
faqId=key_main_kcb_faq_004,
isEnd=1
},
faqId=key_main_kcb_faq_001,
isEnd=1
}
},说={吧={faqId=key_main_kcb_faq_003, isEnd=1}, isEnd=0},
您={说={faqId=key_main_kcb_faq_003, isEnd=1}, isEnd=0},
改={天={吧={faqId=key_main_kcb_faq_004, isEnd=1}, isEnd=0}, isEnd=0},
不={需={要={faqId=key_main_kcb_faq_002, isEnd=1}, isEnd=0}, isEnd=0}
}
解释:
问题:你好啊
匹配结果:绿色字体部分,完整都匹配上,faqId:key_main_kcb_faq_004
问题:你好
匹配结果:红色字体部分,完整匹配上,faqId:key_main_kcb_faq_001
举例:客户说了一长段“你好啊啊啊啊”,就会匹配上绿色部分,因为dfa算法最大匹配原则可以匹配到“你好啊”。