Java 敏感词替换

词库文件：用逗号隔开，格式见下图： 1、初始化敏感词库，将敏感词加入到HashMap中，构建DFA算法模型

package com.iflytek.dfaUtil;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
 * @Description: 初始化敏感词库，将敏感词加入到HashMap中，构建DFA算法模型
 * @Project：test
 * @Author : SPF
 * @version 1.0
 */
public class SensitiveWordInit {
	private static String ENCODING = "UTF-8"; //字符编码
	
    @SuppressWarnings("rawtypes") 
    public static HashMap sensitiveWordMap; 
    
    public SensitiveWordInit(){ 
	    super(); 
	}
    
    /**
     * 初始化词库
     * @param datas 敏感词集合
     * @return
     */
    public static HashMap init(List datas) { 
    	addSensitiveWord(datas); 
    	return sensitiveWordMap; 
    }
    
    /**
     * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：
     * */
    private static void addSensitiveWord(List datas) { 
    	sensitiveWordMap = new HashMap(datas.size()); 
    	Iterator iterator = datas.iterator(); 
    	Map now = null; 
    	Map now2 = null; 
    	while (iterator.hasNext()) { 
	    	now2 = sensitiveWordMap; 
	    	String word = iterator.next().trim(); //敏感词
	    	for (int i = 0; i < word.length(); i++) { 
		    	char key_word = word.charAt(i); 
		    	Object obj = now2.get(key_word); 
		    	if (obj != null) { //存在               
		    		now2 = (Map) obj; 
		    	} else { //不存在
			    	 now = new HashMap(); 
			    	 now.put("isEnd","0"); 
			    	 now2.put(key_word, now); 
			    	 now2 = now; 
		    	} 
		    	if (i == word.length() - 1) { 
		    		now2.put("isEnd","1");
		    	} 
	    	 } 
    	} 
    }
    
    /**
     * 获取内容中的敏感词
     * @param text 内容
     * @param matchType 匹配规则 1=不最佳匹配，2=最佳匹配
     * @return
     */
    public static List getSensitiveWord(String text, int matchType) { 
    	List words = new ArrayList(); 
    	Map now = sensitiveWordMap; 
    	int count = 0; //初始化敏感词长度
    	int start = 0; //标志敏感词开始的下标
    	for (int i = 0; i < text.length(); i++) { 
    		char key = text.charAt(i); 
    		now = (Map) now.get(key); 
    		if (now != null) { //存在
    			count++; 
	            if (count ==1) { 
	        	  start = i; 
	        	} 
	            if ("1".equals(now.get("isEnd"))) { //敏感词结束
	             now = sensitiveWordMap; //重新获取敏感词库
	             words.add(text.substring(start, start + count)); //取出敏感词，添加到集合
	             count = 0; //初始化敏感词长度
	            } 
            } else { //不存在
            	now = sensitiveWordMap;//重新获取敏感词库
            	if (count == 1 && matchType == 1) { //不最佳匹配
            		count = 0; 
            	} else if (count == 1 && matchType == 2) { //最佳匹配
            		words.add(text.substring(start, start + count)); 
            		count = 0; 
            	} 
            } 
    	} 
    	return words; 
    }
    
    /**
     * 从文件中读取词库中的内容，将内容添加到list集合中
     * @author zhiju.li
     * @date 2019年4月12日 下午2:31:18
     * @return
     * @version 1.0
     * @throws Exception
     */
    @SuppressWarnings("resource") 
    public static List readSensitiveWordFile() throws Exception{ 
    	List list = null; 
    	//File file = new File("msc/SensitiveWord.txt"); //读取文件
    	File file = new File("D:\\SensitiveWord.txt"); //读取文件
    	InputStreamReader read = new InputStreamReader(new FileInputStream(file),ENCODING); 
    	try { 
    		if(file.isFile() && file.exists()){ //文件流是否存在
    			list = new ArrayList(); 
		         BufferedReader bufferedReader = new BufferedReader(read); 
		         String txt = null;
		         while((txt = bufferedReader.readLine()) != null){ //读取文件，将文件内容放入到set中
		        	 String[] strSplit=txt.trim().split(",");
		        	 for(String str:strSplit){
		        		 list.add(str); 
		        	 }
		         } 
		    }else{ //不存在抛出异常信息
		    	throw new Exception("词库文件不存在"); 
    		} 
    	} catch (Exception e) { 
    			throw e; 
    	}finally{ 
    		read.close(); //关闭文件流
    	} 
    	return list; 
    } 

}

2、敏感词过滤

package com.iflytek.dfaUtil;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @Description: 敏感词过滤
 * @Project：test
 * @version 1.0
 */
public class SensitivewordFilter {
	 @SuppressWarnings("rawtypes") 
	 private static Map sensitiveWordMap = null; 
	 public static int minMatchTYpe = 1; //最小匹配规则
	 public static int maxMatchType = 2; //最大匹配规则

	 private static void initSensitiveWord(List datas) {
		 sensitiveWordMap = SensitiveWordInit.init(datas); 
	 }
  /**
    * 替换敏感字字符
    * @author chenming
    * @date 2014年4月20日 下午5:12:07
    * @param txt
    * @param matchType
    * @param replaceChar 替换字符，默认*
    * @version 1.0
    */
	 public static String replaceSensitiveWord(List datas, String txt,int matchType,String replaceChar){ 
		 if (sensitiveWordMap == null) { 
			 initSensitiveWord(datas); 
	     } 
		 String resultTxt = txt; 
		 List set = SensitiveWordInit.getSensitiveWord(txt, matchType); //获取所有的敏感词
		 System.out.println(set); 
		 Iterator iterator = set.iterator(); 
		 String word = null; 
		 String replaceString = null; 
		 while (iterator.hasNext()) { 
			 word = iterator.next(); 
			 replaceString = getReplaceChars(replaceChar, word.length()); 
			 resultTxt = resultTxt.replaceAll(word, replaceString); 
		 }
		 
		 return resultTxt; 
	}
  /**
    * 获取与词库中相匹配的词语
    * @author chenming
    * @date 2014年4月20日 下午5:12:07
    * @param txt
    * @param matchType
    * @param replaceChar 替换字符，默认*
    * @version 1.0
    */
	 public static List getSensitiveWord(List datas, String txt,int matchType){ 
		 if (sensitiveWordMap == null) { 
			 initSensitiveWord(datas); 
	     } 
		 List list = SensitiveWordInit.getSensitiveWord(txt, matchType); //获取所有的敏感词
		 return list; 
	}
  /**
    * 获取替换字符串
    * @author chenming
    * @date 2014年4月20日 下午5:21:19
    * @param replaceChar
    * @param length
    * @return
    * @version 1.0
    */
	 private static String getReplaceChars(String replaceChar,int length){ 
		 String resultReplace = replaceChar;
		 if (length > 6) { 
			 length = 6; 
		 } 
		 for(int i = 1 ; i < length ; i++){ 
			 resultReplace += replaceChar; 
		 } 
		 return resultReplace; 
	}
	 
  /**
    * 添加敏感词
    * @param str
    */
	 private static boolean addSensitiveWord(String str) { 
		if (sensitiveWordMap == null) { 
			 return false; 
		} 
		Map nowMap = null; 
		Map newWorMap = null; 
		nowMap = sensitiveWordMap; 
		for(int i = 0 ; i < str.length() ; i++){ 
			 char keyChar = str.charAt(i); //转换成char型
			 Object wordMap = nowMap.get(keyChar); //获取
			 if(wordMap != null){ //如果存在该key，直接赋值
				 nowMap = (Map) wordMap; 
			 }else{ //不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个
				 newWorMap = new HashMap(); 
				 newWorMap.put("isEnd", "0"); //不是最后一个
				 nowMap.put(keyChar, newWorMap); 
				 nowMap = newWorMap;
			 } 
			 if(i == str.length() - 1){ 
				 nowMap.put("isEnd", "1"); //最后一个
			 } 
        } 
		 return  true; 
     }



}

3、测试方法：

package com.iflytek.dfaUtil;

import java.util.List;

public class MainTest {
	 public static void main(String[] args) throws Exception {
		 //从文件中读取词库中的内容，将内容添加到list集合中
		 List datas= SensitiveWordInit.readSensitiveWordFile();
		 //初始化词库,读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：
		 SensitiveWordInit.init(datas);
		 //输入的字符串
		 String str = "你好，帮我查看下今天的天气状况信息"; 
		 //List rep = SensitivewordFilter.getSensitiveWord(datas,str,1); 
		 String rep = SensitivewordFilter.replaceSensitiveWord(datas,str,1,"*"); 
		 System.out.println(rep); 
		 
	}
	
}

4、效果图： 本文参考：https://blog.csdn.net/qq_32331997/article/details/73732493，在此基础上进行一些更改。