JAVA做敏感词统计——DFA 算法

DFA，全称 Deterministic Finite Automaton 即确定有穷自动机：从一个状态通过一系列的事件转换到另一个状态，即 state -> event -> state。

　　确定：状态以及引起状态转换的事件都是可确定的，不存在“意外”。
　　有穷：状态以及事件的数量都是可穷举的
详细的算法大家可以自行鸟姐下哈。今天咱们主要讲下DFA算法进行敏感词统计

比如说有以下这些敏感词

【二傻子，不太行，二傻子吧？】

咱们先分析下。如果不用DFA算法。咱们就得用正则表达式匹配。看下是否包含这两个词。

但是这样的话效率太低了。会随着被匹配内容的增加进行指数型增加（也就是O(2ⁿ)）

接下咱们可以想着优化下

可以发现如果这个文本都不包含`二`就更不会包含 二傻子

以此类推 包含 `二` 但是后边不是 `傻` 那也不包含敏感词  再以此类推

转成Java思维 

{二={End=0, 傻={子={End=1}, End=0,吧={？={End=1}}}  必须把链路走完才是敏感词。也就是有1

上边这个json就可以用Java当中的Map来实现。上代码

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.*;

/**
 * 敏感词对象
 */
@Service
public class SensitiveWord {

    //分布式锁
    private static IDistributedLock distributedLock;

    @Autowired
    public void setIDistributedLock(IDistributedLock distributedLock) {
        SensitiveWord.distributedLock = distributedLock;
    }


    /**
     * 铭感词状态 false 未初始化 ture已初始化
     */
    public static boolean status;
    public static HashMap sensitiveWordMap;

    public SensitiveWord() {
        super();
    }

    /**
     *
     */
    @SuppressWarnings("rawtypes")
    public static Map initKeyWord() {
        String distributedLockKey = "information:applyCredit:admin:wscs";
        try {

            if (!distributedLock.tryLock(distributedLockKey, 3, -1)) {
                throw BusinessException.of(CommonCodeMsg.TOO_FREQUENT);
            }
            status = false;
            //读取敏感词库
            Set<String> keyWordSet = readSensitiveWordFile();
            //将敏感词库加入到HashMap中
            addSensitiveWordToHashMap(keyWordSet);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            status = true;
            // 待事务提交后再释放锁
            SpringUtils.afterCompletion(() -> distributedLock.release(distributedLockKey));
        }
        return sensitiveWordMap;
    }


    /**
     * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：<br>
     * 中 = {
     * isEnd = 0
     * 国 = {<br>
     * isEnd = 1
     * 人 = {isEnd = 0
     * 民 = {isEnd = 1}
     * }
     * 男  = {
     * isEnd = 0
     * 人 = {
     * isEnd = 1
     * }
     * }
     * }
     * }
     * 五 = {
     * isEnd = 0
     * 星 = {
     * isEnd = 0
     * 红 = {
     * isEnd = 0
     * 旗 = {
     * isEnd = 1
     * }
     * }
     * }
     * }
     *
     * @param keyWordSet 敏感词库
     * @version 1.0
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    public static 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");    //最后一个
                }
            }
        }
    }

    /**
     * 读取敏感词库中的内容，将内容添加到set集合中
     *
     * @return
     * @throws Exception
     */
    @SuppressWarnings("resource")
    public static Set<String> readSensitiveWordFile() throws Exception {
        Set<String> set = null;

        File file = new File("D:\\SensitiveWord.txt");    //读取文件
        InputStreamReader read = new InputStreamReader(new FileInputStream(file), "UTF-8");
        try {
            if (file.isFile() && file.exists()) {      //文件流是否存在
                set = new HashSet<String>();
                BufferedReader bufferedReader = new BufferedReader(read);
                String txt = null;
                while ((txt = bufferedReader.readLine()) != null) {    //读取文件，将文件内容放入到set中
                    set.add(txt);
                }
            } else {         //不存在抛出异常信息
                throw new Exception("敏感词库文件不存在");
            }
        } catch (Exception e) {
            throw e;
        } finally {
            read.close();     //关闭文件流
        }
        return set;
    }

}

 酱紫就会把所有的敏感词都先缓存。然后再进行敏感词过滤

/**
     * 敏感词过滤
     */
    public void sensitiveWordFilter() {

        String text = "这是一段需要检测的文字。知道了吗？二傻子？";
        for (int i = 0; i < text.length(); i++) {
            boolean isExist = this.checkSensitiveWord(text, i);
            //判断是否包含敏感字符
            if (isExist) {
                System.out.println("你惨了，你说话都是星星");
                return;
            }

        }

    }


    /**
     * 检查文字中是否包含敏感字符，检查规则如下：<br>
     *
     * @param txt        需要检测的文字
     * @param beginIndex 开始检测的位置
     */
    @SuppressWarnings({"rawtypes"})
    public boolean checkSensitiveWord(String txt, int beginIndex) {
        Map nowMap = SensitiveWord.sensitiveWordMap;
        for (int i = beginIndex; i < txt.length(); i++) {
            char word = txt.charAt(i);
            nowMap = (Map) nowMap.get(word);     //获取指定key
            if (nowMap != null) {     //存在，则判断是否为最后一个
                if ("1".equals(nowMap.get("isEnd"))) {
                    return true;       //结束标志位为true
                }
            } else {
                //不存在，直接返回
                break;
            }
        }
        return false;
    }

可以看到这样做，时间复杂度就会降到O(n2)。可以说是非常的不错啦

课后作业

1.统计敏感词字数

2.把敏感词替换成***