文章大约分为以下3个部分：
1、应用背景；
2、AC算法介绍及其原理；
3、AC算法的Java实现；
1、应用背景
在互联网应用中，通常会用到关键词检测功能，以防止用户发表包括了指定关键词的内容。如游戏的聊天系统、角色名称检测，论坛发帖、直播弹幕等，都需要对用户发布的内容进行检测，以检测是否包含敏感的关键字。
通常需要检测的关键词，会有很多很多，比如侮辱人的关键词，政治敏感的关键词，系统相关的特定关键词等。毫不夸张的说，通常要检测的关键词会有几千个，甚至过万。这时效率都变得尤为突出，如果检测关键词的效率低下，对大型互联网应用来说，很可能有是致命的。
以8000个关键词为例，如果使用正则表达式，则需要对用户发布的内容遍历8000遍。如果同一秒中，有100位，1000位，10000位...用户发布内容，可想而知仅仅在关键词检测方面服务器上CPU的开销。
AC多模式匹配算法，可以有效的解决关键词检测的效率问题。时间复杂度为O(n),n为用户发布内容的长度n。基本与关键词的数量无关。
2、AC算法介绍及其原理
AC算法是Alfred V.Aho（《编译原理》的作者），和Margaret J.Corasick于1974年提出（与KMP算法同年）的一个经典的多模式匹配算法，可以保证对于给定的长度为n的文本，和模式集合P{p1,p2,...pm}，在O(n)时间复杂度内，找到文本中的所有目标模式，而与模式集合的规模m无关。
AC算法实现原理，大体上可分为三步：
1）、构建敏感词树型结构，并标注结束节点（即是否是一个敏感词的结束）；
2）、为树上的结点，构建匹配失败时的跳转-失败结点（即匹配失败时，跳转到哪个结点继续匹配）；
3）、对用户内容进行一次遍历，对于每个字符（字节）都去敏感词树型结构中，从当前结点位置开始匹配。
如果匹配成功，则当前结点，下移到对应的结点。如果当前结点为“结束节点”，则表示匹配成功；
如果匹配失败，则当前结点，跳转到该结点的失败结点，继续匹配，直到匹配成功或当前结点为根结点；
1）构建敏感词树型结构，并标注结束节点（即是否是一个敏感词的结束）
首先要有一个根结点；
遍历所有的敏感词，将每个敏感词的每一个字节，放到树上，成为一个结点。每一个字节的前一字节所对应的结点，都为该字节所对应结点的父结点。如果字节所对应的结点已存在，则不再添加新的结点。如果该字节为敏感词的最后一个字节，则将对应结点，设置为结束结点。
如敏感词：he,hers,his,erase
2）为树上的结点，构建匹配失败时的跳转-失败结点（即匹配失败时，跳转到哪个结点继续匹配）
第一层子节点的失败节点，直接指定是根结点；
其它子节点的失败节点，是其父结点的失败点中查找相应的路径。如果查不到，则继续在当前结点的失败结点中查找相应的路径。直到找相应的节点，或失败节点为根结点。
3)对用户内容进行一次遍历，对于每个字符（字节）都去敏感词树型结构中，从当前结点位置开始匹配。
如果匹配成功，则当前结点，下移到对应的结点。如果当前结点为“结束节点”，则表示匹配成功；
如果匹配失败，则当前结点，跳转到该结点的失败结点，继续匹配，直到匹配成功或当前结点为根结点；
以herase为类，演示
3、AC算法的Java实现
数据结构，关键词树上的结点Node.java
package cn.buddie.ac.model;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* 结点类
*
* @author buddie
*
*/
public class Node {
// 当前结点的层级
private int level;
// 当前结点后子结点，Key为小写字母
private Map<Character, Node> subNodes;
// 当前结果匹配失败时的跳转结点
private Node failNode;
// 当前结点是否是终结结点
private boolean terminal;
/**
* 当前结点是否已包含指定Key值的子结点
*
* @param c
* @return
*/
public boolean containSubNode(Character c) {
if (this.subNodes == null || this.subNodes.isEmpty()) {
return false;
}
return subNodes.containsKey(c);
}
/**
* 获取指定Key值的子结点
*
* @param c
* @return
*/
public Node getSubNode(Character c) {
if (this.subNodes == null || this.subNodes.isEmpty()) {
return null;
}
return subNodes.get(c);
}
/**
* 添加子结点
*
* @param c
* @param node
*/
public void addSubNode(Character c, Node node) {
if (this.subNodes == null) {
this.subNodes = new HashMap<Character, Node>();
}
this.subNodes.put(c, node);
}
// getter & setter
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public Map<Character, Node> getSubNodes() {
return subNodes == null ? Collections.emptyMap() : subNodes;
}
public void setSubNodes(Map<Character, Node> subNodes) {
this.subNodes = subNodes;
}
public Node getFailNode() {
return failNode;
}
public void setFailNode(Node failNode) {
this.failNode = failNode;
}
public boolean isTerminal() {
return terminal;
}
public void setTerminal(boolean terminal) {
this.terminal = terminal;
}
}
构建关键词树，关构建失败结点
package cn.buddie.ac.tree;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
import cn.buddie.ac.model.Node;
public class ACTree {
private Node rootNode;
public ACTree(String[] keyWords) {
// 初始树
initTree(keyWords);
// 构建失败跳转
buildFailLink();
}
/**
* 初始树
*
* @param keyWords
*/
private void initTree(String[] keyWords) {
rootNode = new Node();
rootNode.setSubNodes(new HashMap<Character, Node>());
char[] charArray;
for (String keyWord : keyWords) {
if (keyWord.isEmpty()) {
continue;
}
charArray = keyWord.toLowerCase().toCharArray();
buildKeyMap(charArray);
}
}
/**
* 构建指定字符数组的结点
*
* @param charArray
*/
private void buildKeyMap(char[] charArray) {
Character c;
Node curNode = rootNode;
Node node;
for (int i = 0; i < charArray.length; i++) {
c = charArray[i];
if (curNode.containSubNode(c)) {
node = curNode.getSubNode(c);
} else {
node = new Node();
node.setLevel(i + 1);
curNode.addSubNode(c, node);
}
if (i == charArray.length - 1) {
node.setTerminal(true);
}
curNode = node;
}
}
/**
* 构建失败跳转
*/
private void buildFailLink() {
buildFirstLevelFailLink();
buildOtherLevelFailLink();
}
/**
* 根结点的所有第一级子结点，失败跳转均为根结点
*/
private void buildFirstLevelFailLink() {
Collection<Node> nodes = rootNode.getSubNodes().values();
for (Node node : nodes) {
node.setFailNode(rootNode);
}
}
/**
* 根结点、第一级结点以外的所有结点，失败跳转均为其父结点的失败结点的对应子结点
*/
private void buildOtherLevelFailLink() {
Queue<Node> queue = new LinkedList<Node>(rootNode.getSubNodes().values());
Node node;
while (!queue.isEmpty()) {
node = queue.remove();
buildNodeFailLink(node, queue);
}
}
/**
* 构建指定结点的下一层结点的失败跳转
*
* @param node
*/
private void buildNodeFailLink(Node node, Queue<Node> queue) {
if (node.getSubNodes().isEmpty()) {
return;
}
queue.addAll(node.getSubNodes().values());
Node failNode = node.getFailNode();
Set<Character> subNodeKeys = node.getSubNodes().keySet();
Node subFailNode;
for (Character key : subNodeKeys) {
subFailNode = failNode;
while (subFailNode != rootNode && !subFailNode.containSubNode(key)) {
subFailNode = subFailNode.getFailNode();
}
subFailNode = subFailNode.getSubNode(key);
if (subFailNode == null) {
subFailNode = rootNode;
}
node.getSubNode(key).setFailNode(subFailNode);
}
}
// getter
public Node getRootNode() {
return rootNode;
}
}
过滤、替换工具类
package cn.buddie.ac.filter;
import org.apache.commons.lang.StringUtils;
import cn.buddie.ac.model.Node;
import cn.buddie.ac.tree.ACTree;
public class ACFilter {
public static final Character REPLACE_CHAR = '*';
private ACTree tree;
public ACFilter(ACTree tree) {
this.tree = tree;
}
/**
* 过滤
*
* @param word
* @return
*/
public String filter(String word) {
if (StringUtils.isEmpty(word)) {
return "";
}
char[] words = word.toLowerCase().toCharArray();
char[] result = null;
Node curNode = tree.getRootNode();
Node subNode;
Character c;
int fromPos = 0;
for (int i = 0; i < words.length; i++) {
c = words[i];
subNode = curNode.getSubNode(c);
while (subNode == null && curNode != tree.getRootNode()) {
curNode = curNode.getFailNode();
subNode = curNode.getSubNode(c);
}
if (subNode != null) {
curNode = subNode;
}
if (curNode.isTerminal()) {
int pos = i - curNode.getLevel() + 1;
if (pos < fromPos) {
pos = fromPos;
}
if (result == null) {
result = word.toLowerCase().toCharArray();
}
for (; pos <= i; pos++) {
result[pos] = REPLACE_CHAR;
}
fromPos = i + 1;
}
}
if (result == null) {
return word;
}
return String.valueOf(result);
}
}
Demo
package cn.buddie.ac;
import cn.buddie.ac.filter.ACFilter;
import cn.buddie.ac.tree.ACTree;
public class WordFilterTest {
public static void main(String[] args) {
String[] keyWords = new String[] { "he", "hers", "his", "erase" };
ACTree tree = new ACTree(keyWords);
ACFilter filter = new ACFilter(tree);
String str = "herase";
str = filter.filter(str);
System.out.println(str);
}
}