java脏字过滤_脏字过滤
1.[文件]
SensitiveWordFilter.java?~?7KB
下載(141)
package com.forgov.sharpc.infrastruture.util;
import static java.util.Collections.sort;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
/**
*
* @author loudyn
*
*/
public class SensitiveWordFilter {
private WordNode rootWordNode = new WordNode(null, 'R', WordNode.MIDSIDE_TYPE);
/**
*
* @param word
* @return
*/
public final SensitiveWordFilter addFilterWord(String word) {
char[] chars = word.toCharArray();
if (chars.length > 0) {
insertWordNode(rootWordNode, chars, 0);
}
return this;
}
/**
*
* @param word
* @return
*/
public final SensitiveWordFilter removeFilterWord(String word) {
char[] chars = word.toCharArray();
if (chars.length > 0) {
removeWordNode(rootWordNode, chars, 0);
}
return this;
}
/**
*
* @param wordNode
* @param chars
* @param index
*/
private void removeWordNode(WordNode wordNode, char[] chars, int index) {
convertEnglishAlphabetToLowerCase(chars, index);
WordNode node = searchWordNode(wordNode, chars[index]);
if (null == node) {
return;
}
if (index == chars.length - 1) {
node.type = WordNode.MIDSIDE_TYPE;
}
if (++index < chars.length) {
removeWordNode(node, chars, index);
}
}
/**
*
* @param words
* @return
*/
public final SensitiveWordFilter addFilterWords(Collection words) {
for (String word : words) {
addFilterWord(word);
}
return this;
}
/**
*
* @param words
* @return
*/
public final SensitiveWordFilter removeFilterWords(Collection words) {
for (String word : words) {
removeFilterWord(word);
}
return this;
}
/**
*
* @return
*/
public final SensitiveWordFilter reset() {
destroyFilterWordTree(rootWordNode);
rootWordNode = new WordNode(null, 'R', WordNode.MIDSIDE_TYPE);
return this;
}
/**
*
* @param wordnode
* @return
*/
private SensitiveWordFilter destroyFilterWordTree(WordNode wordnode) {
if (null != wordnode.children && !wordnode.children.isEmpty()) {
for (WordNode node : wordnode.children) {
destroyFilterWordTree(node);
}
}
wordnode.children = null;
wordnode = null;
return this;
}
/**
*
* @param text
* @param replacement
* @return
*/
public final String doFilter(String text, String replacement) {
List hitWords = new LinkedList();
try {
if (beforeFilter(text, replacement)) {
hitWords = hit(text);
return doInternalFilter(text, hitWords, replacement);
}
} catch (Exception e) {
ExceptionUtils.toUnchecked(e);
} finally {
afterFilter(hitWords, text, replacement);
}
return text;
}
/**
*
* @param wordNode
* @param chars
* @param index
*/
private void insertWordNode(WordNode wordNode, char[] chars, int index) {
convertEnglishAlphabetToLowerCase(chars, index);
WordNode node = searchWordNode(wordNode, chars[index]);
if (null == node) {
node = new WordNode(wordNode, chars[index], WordNode.MIDSIDE_TYPE);
wordNode.children.add(node);
}
if (index == chars.length - 1) {
node.type = node.children.isEmpty() ? WordNode.END_TYPE : WordNode.BOTH_TYPE;
}
if (node.parent.type == WordNode.END_TYPE) {
node.parent.type = WordNode.BOTH_TYPE;
}
if (++index < chars.length) {
insertWordNode(node, chars, index);
}
}
/**
*
* @param chars
* @param index
*/
private void convertEnglishAlphabetToLowerCase(char[] chars, int index) {
if (chars[index] >= 65 && chars[index] <= 90) {
chars[index] = (char) (chars[index] + 32);
}
}
/**
*
* @param wordNode
* @param c
* @return
*/
private WordNode searchWordNode(WordNode wordNode, char c) {
List children = wordNode.children;
for (WordNode node : children) {
if (node.value == c) {
return node;
}
}
return null;
}
/**
*
* @param text
* @param replacement
* @return
*/
protected boolean beforeFilter(String text, String replacement) {
// add hook by overwrite this method;
return true;
}
/**
*
* @param text
* @return
*/
private List hit(String text) {
List hitWords = new LinkedList();
List foundChars = new LinkedList();
WordNode node = rootWordNode;
int index = 0;
char[] chars = text.toCharArray();
while (index < chars.length) {
convertEnglishAlphabetToLowerCase(chars, index);
node = searchWordNode(node, chars[index]);
if (null == node) {
node = rootWordNode;
index -= foundChars.size();
foundChars.clear();
}
else if (node.type == WordNode.END_TYPE) {
node = rootWordNode;
foundChars.add(chars[index]);
hitWords.add(charListToString(foundChars));
index -= (foundChars.size() - 1);
foundChars.clear();
}
else if (node.type == WordNode.BOTH_TYPE) {
foundChars.add(chars[index]);
hitWords.add(charListToString(foundChars));
}
else {
foundChars.add(chars[index]);
}
index++;
}
return hitWords;
}
/**
*
* @param hitWords
* @param text
* @param replacement
*/
protected void afterFilter(List hitWords, String text, String replacement) {
// add hook by overwrite this method;
}
/**
*
* @param chars
* @return
*/
private String charListToString(List chars) {
StringBuilder buf = new StringBuilder();
for (char c : chars) {
buf.append(c);
}
return buf.toString();
}
/**
*
* @param text
* @param hitWords
* @param replacement
* @return
*/
private String doInternalFilter(String text, List hitWords, String replacement) {
List copy = new ArrayList(new HashSet(hitWords));
hitWords.clear();
hitWords.addAll(copy);
sort(hitWords, WORD_COMPARATOR);
for (String foundWord : hitWords) {
text = text.replaceAll("(?iu)" + foundWord, replacement);
}
return text;
}
private final static Comparator WORD_COMPARATOR = new Comparator() {
public int compare(String one, String other) {
return other.length() - one.length();
}
};
/**
*
* @author loudyn
*
*/
protected static final class WordNode {
static final int END_TYPE = 1;
static final int MIDSIDE_TYPE = 1 << 1;
static final int BOTH_TYPE = END_TYPE | MIDSIDE_TYPE;
final char value;
int type;
WordNode parent;
List children = new ArrayList(0);
WordNode(WordNode parent, char value, int type) {
this.parent = parent;
this.value = value;
this.type = type;
}
}
}
總結(jié)
以上是生活随笔為你收集整理的java脏字过滤_脏字过滤的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
