java中敏感词过滤工具类

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.ckpi.utils;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Repository;

@Repository
public class SensitiveUtils {
    public static final int MinMatchTYpe = 1;
    public static final int MaxMatchType = 2;
    public static HashMap sensitiveWordMap;

    public SensitiveUtils() {
    }

    public static synchronized void init(Set<String> sensitiveWordSet) {
        initSensitiveWordMap(sensitiveWordSet);
    }

    private static void initSensitiveWordMap(Set<String> sensitiveWordSet) {
        sensitiveWordMap = new HashMap(sensitiveWordSet.size());
        Iterator iterator = sensitiveWordSet.iterator();

        while(iterator.hasNext()) {
            String key = (String)iterator.next();
            Map nowMap = sensitiveWordMap;

            for(int i = 0; i < key.length(); ++i) {
                char keyChar = key.charAt(i);
                Object wordMap = ((Map)nowMap).get(keyChar);
                if (wordMap != null) {
                    nowMap = (Map)wordMap;
                } else {
                    Map<String, String> newWorMap = new HashMap();
                    newWorMap.put("isEnd", "0");
                    ((Map)nowMap).put(keyChar, newWorMap);
                    nowMap = newWorMap;
                }

                if (i == key.length() - 1) {
                    ((Map)nowMap).put("isEnd", "1");
                }
            }
        }

    }

    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) {
                flag = true;
            }
        }

        return flag;
    }

    public static boolean contains(String txt) {
        return contains(txt, 2);
    }

    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) {
                sensitiveWordList.add(txt.substring(i, i + length));
                i = i + length - 1;
            }
        }

        return sensitiveWordList;
    }

    public static Set<String> getSensitiveWord(String txt) {
        return getSensitiveWord(txt, 2);
    }

    public static String replaceSensitiveWord(String txt, char replaceChar, int matchType) {
        String resultTxt = txt;
        Set<String> set = getSensitiveWord(txt, matchType);

        String word;
        String replaceString;
        for(Iterator iterator = set.iterator(); iterator.hasNext(); resultTxt = resultTxt.replaceAll(word, replaceString)) {
            word = (String)iterator.next();
            replaceString = getReplaceChars(replaceChar, word.length());
        }

        return resultTxt;
    }

    public static String replaceSensitiveWord(String txt, char replaceChar) {
        return replaceSensitiveWord(txt, replaceChar, 2);
    }

    public static String replaceSensitiveWord(String txt, String replaceStr, int matchType) {
        String resultTxt = txt;
        Set<String> set = getSensitiveWord(txt, matchType);

        String word;
        for(Iterator iterator = set.iterator(); iterator.hasNext(); resultTxt = resultTxt.replaceAll(word, replaceStr)) {
            word = (String)iterator.next();
        }

        return resultTxt;
    }

    public static String replaceSensitiveWord(String txt, String replaceStr) {
        return replaceSensitiveWord(txt, replaceStr, 2);
    }

    private static String getReplaceChars(char replaceChar, int length) {
        String resultReplace = String.valueOf(replaceChar);

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

        return resultReplace;
    }

    private static int checkSensitiveWord(String txt, int beginIndex, int matchType) {
        boolean flag = false;
        int matchFlag = 0;
        Map nowMap = sensitiveWordMap;

        for(int i = beginIndex; i < txt.length(); ++i) {
            char word = txt.charAt(i);
            nowMap = (Map)((Map)nowMap).get(word);
            if (nowMap == null) {
                break;
            }

            ++matchFlag;
            if ("1".equals(((Map)nowMap).get("isEnd"))) {
                flag = true;
                if (1 == matchType) {
                    break;
                }
            }
        }

        if (matchFlag < 2 || !flag) {
            matchFlag = 0;
        }

        return matchFlag;
    }

    public static String sensitiveHelper(String string) {
        string = string.replaceAll(" +", "").replaceAll("　+", "");
        String str = "这里是敏感词";
        Set<String> sensitiveWordSet = new HashSet();
        String[] arr = str.split(",");
        String[] var4 = arr;
        int var5 = arr.length;

        for(int var6 = 0; var6 < var5; ++var6) {
            String c = var4[var6];
            sensitiveWordSet.add(c);
        }

        init(sensitiveWordSet);
        if (contains(string)) {
            String restr = replaceSensitiveWord(string, "**");
            return restr;
        } else {
            return string;
        }
    }
}