for (String document : documents) {
 for (String filterWord : filterWords) {
  if (document.contains(filterWord)) {
   //process ...
  }
 }
}

import java.util.*;
/**
 */
public class ACTrie {
	private Boolean failureStatesConstructed = false;
	//是否建立了failure表
	private Node root;
	//根結(jié)點(diǎn)
	public ACTrie() {
		this.root = new Node(true);
	}
	/**
  * 添加一個模式串
  * @param keyword
  */
	public void addKeyword(String keyword) {
		if (keyword == null || keyword.length() == 0) {
			return;
		}
		Node currentState = this.root;
		for (Character character : keyword.toCharArray()) {
			currentState = currentState.insert(character);
		}
		currentState.addEmit(keyword);
	}
	/**
  * 模式匹配
  *
  * @param text 待匹配的文本
  * @return 匹配到的模式串
  */
	public Collection<Emit> parseText(String text) {
		checkForConstructedFailureStates();
		Node currentState = this.root;
		List<Emit> collectedEmits = new ArrayList<>();
		for (int position = 0; position < text.length(); position++) {
			Character character = text.charAt(position);
			currentState = currentState.nextState(character);
			Collection<String> emits = currentState.emit();
			if (emits == null || emits.isEmpty()) {
				continue;
			}
			for (String emit : emits) {
				collectedEmits.add(new Emit(position - emit.length() + 1, position, emit));
			}
		}
		return collectedEmits;
	}
	/**
  * 檢查是否建立了failure表
  */
	private void checkForConstructedFailureStates() {
		if (!this.failureStatesConstructed) {
			constructFailureStates();
		}
	}
	/**
  * 建立failure表
  */
	private void constructFailureStates() {
		Queue<Node> queue = new LinkedList<>();
		// 第一步，將深度為1的節(jié)點(diǎn)的failure設(shè)為根節(jié)點(diǎn)
		//特殊處理：第二層要特殊處理，將這層中的節(jié)點(diǎn)的失敗路徑直接指向父節(jié)點(diǎn)(也就是根節(jié)點(diǎn))。
		for (Node depthOneState : this.root.children()) {
			depthOneState.setFailure(this.root);
			queue.add(depthOneState);
		}
		this.failureStatesConstructed = true;
		// 第二步，為深度 > 1 的節(jié)點(diǎn)建立failure表，這是一個bfs 廣度優(yōu)先遍歷
		/**
   * 構(gòu)造失敗指針的過程概括起來就一句話：設(shè)這個節(jié)點(diǎn)上的字母為C，沿著他父親的失敗指針走，直到走到一個節(jié)點(diǎn)，他的兒子中也有字母為C的節(jié)點(diǎn)。
   * 然后把當(dāng)前節(jié)點(diǎn)的失敗指針指向那個字母也為C的兒子。如果一直走到了root都沒找到，那就把失敗指針指向root。
   * 使用廣度優(yōu)先搜索BFS，層次遍歷節(jié)點(diǎn)來處理，每一個節(jié)點(diǎn)的失敗路徑。　　
   */
		while (!queue.isEmpty()) {
			Node parentNode = queue.poll();
			for (Character transition : parentNode.getTransitions()) {
				Node childNode = parentNode.find(transition);
				queue.add(childNode);
				Node failNode = parentNode.getFailure().nextState(transition);
				childNode.setFailure(failNode);
				childNode.addEmit(failNode.emit());
			}
		}
	}
	private static class Node{
		private Map<Character, Node> map;
		private List<String> emits;
		//輸出
		private Node failure;
		//失敗中轉(zhuǎn)
		private Boolean isRoot = false;
		//是否為根結(jié)點(diǎn)
		public Node(){
			map = new HashMap<>();
			emits = new ArrayList<>();
		}
		public Node(Boolean isRoot) {
			this();
			this.isRoot = isRoot;
		}
		public Node insert(Character character) {
			Node node = this.map.get(character);
			if (node == null) {
				node = new Node();
				map.put(character, node);
			}
			return node;
		}
		public void addEmit(String keyword) {
			emits.add(keyword);
		}
		public void addEmit(Collection<String> keywords) {
			emits.addAll(keywords);
		}
		/**
   * success跳轉(zhuǎn)
   * @param character
   * @return
   */
		public Node find(Character character) {
			return map.get(character);
		}
		/**
   * 跳轉(zhuǎn)到下一個狀態(tài)
   * @param transition 接受字符
   * @return 跳轉(zhuǎn)結(jié)果
   */
		private Node nextState(Character transition) {
			Node state = this.find(transition);
			// 先按success跳轉(zhuǎn)
			if (state != null) {
				return state;
			}
			//如果跳轉(zhuǎn)到根結(jié)點(diǎn)還是失敗，則返回根結(jié)點(diǎn)
			if (this.isRoot) {
				return this;
			}
			// 跳轉(zhuǎn)失敗的話，按failure跳轉(zhuǎn)
			return this.failure.nextState(transition);
		}
		public Collection<Node> children() {
			return this.map.values();
		}
		public void setFailure(Node node) {
			failure = node;
		}
		public Node getFailure() {
			return failure;
		}
		public Set<Character> getTransitions() {
			return map.keySet();
		}
		public Collection<String> emit() {
			return this.emits == null ? Collections.<String>emptyList() : this.emits;
		}
	}
	private static class Emit{
		private final String keyword;
		//匹配到的模式串
		private final int start;
		private final int end;
		/**
   * 構(gòu)造一個模式串匹配結(jié)果
   * @param start 起點(diǎn)
   * @param end  重點(diǎn)
   * @param keyword 模式串
   */
		public Emit(final int start, final int end, final String keyword) {
			this.start = start;
			this.end = end;
			this.keyword = keyword;
		}
		/**
   * 獲取對應(yīng)的模式串
   * @return 模式串
   */
		public String getKeyword() {
			return this.keyword;
		}
		@Override
		  public String toString() {
			return super.toString() + "=" + this.keyword;
		}
	}
	public static void main(String[] args) {
		ACTrie trie = new ACTrie();
		trie.addKeyword("hers");
		trie.addKeyword("his");
		trie.addKeyword("she");
		trie.addKeyword("he");
		Collection<Emit> emits = trie.parseText("ushers");
		for (Emit emit : emits) {
			System.out.println(emit.start + " " + emit.end + "\t" + emit.getKeyword());
		}
	}
}