android 过滤敏感词主要类

package com.example.demo;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class SensitiveWordsUtils {

/**

    * 敏感词匹配规则

    */

    public static final int MinMatchTYpe =1;

    public static final int MaxMatchType =2;

    /**

    * 敏感词集合

    */

    public static HashMapsensitiveWordMap;

    /**

    * 初始化敏感词库,构建DFA算法模型

    *

    * @param sensitiveWordSet 敏感词库

    */

    public static synchronized void init(Set sensitiveWordSet) {

initSensitiveWordMap(sensitiveWordSet);

    }

/**

    * 初始化敏感词库,构建DFA算法模型

    *

    * @param sensitiveWordSet 敏感词库

    */

    private static void initSensitiveWordMap(Set sensitiveWordSet) {

//初始化敏感词容器,减少扩容操作

        sensitiveWordMap =new HashMap(sensitiveWordSet.size());

        String key;

        Map nowMap;

        Map newWorMap;

        //迭代sensitiveWordSet

        Iterator 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 SetgetSensitiveWord(String txt, int matchType) {

Set 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 SetgetSensitiveWord(String txt) {

return getSensitiveWord(txt, MaxMatchType);

    }

/**

    * 替换敏感字字符

    *

    * @param txt        文本

    * @param replaceChar 替换的字符,匹配的敏感词以字符逐个替换,如 语句:我爱中国人 敏感词:中国人,替换字符:*, 替换结果:我爱***

    * @param matchType  敏感词匹配规则

    * @return

    */

    public static StringreplaceSensitiveWord(String txt, char replaceChar, int matchType) {

String resultTxt = txt;

        //获取所有的敏感词

        Set set =getSensitiveWord(txt, matchType);

        Iterator 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 StringreplaceSensitiveWord(String txt, char replaceChar) {

return replaceSensitiveWord(txt, replaceChar, MaxMatchType);

    }

/**

    * 替换敏感字字符

    *

    * @param txt        文本

    * @param replaceStr 替换的字符串,匹配的敏感词以字符逐个替换,如 语句:我爱中国人 敏感词:中国人,替换字符串:[屏蔽],替换结果:我爱[屏蔽]

    * @param matchType  敏感词匹配规则

    * @return

    */

    public static StringreplaceSensitiveWord(String txt, String replaceStr, int matchType) {

String resultTxt = txt;

        //获取所有的敏感词

        Set set =getSensitiveWord(txt, matchType);

        Iterator 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 StringreplaceSensitiveWord(String txt, String replaceStr) {

return replaceSensitiveWord(txt, replaceStr, MaxMatchType);

    }

/**

    * 获取替换字符串

    *

    * @param replaceChar

    * @param length

    * @return

    */

    private static StringgetReplaceChars(char replaceChar, int length) {

String resultReplace = String.valueOf(replaceChar);

        for (int i =1; i < length; i++) {

resultReplace += replaceChar;

        }

return resultReplace;

    }

/**

    * 检查文字中是否包含敏感字符,检查规则如下:

    *

    * @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;

    }

}

推荐阅读更多精彩内容