JAVA实现字符串多模匹配

package com.dft;

import java.util.*;

/**
 * @version V1.0
 * @ClassName ACTrie
 * @Description 基于字典树实现AC自动机
 * @Author DFT
 * @Date 2020/5/20 0020
 */
public class ACTrie {
    private boolean failureSetted = false; //是否建立了failure表
    private Node root; //根结点

    public ACTrie() {
        this.root = new Node(true);
    }

    /**
     * @Description 添加一组模式串
     * @Author DFT
     * @Date 2020/5/24 0024
     * @Param [sequences]
     * @return void
     **/
    public void addKeywordList(Collection<? extends CharSequence> sequences){
        if (sequences == null || sequences.isEmpty()) return;
        for (CharSequence sequence : sequences) {
            addKeyword(sequence);
        }
    }

    /**
     * @Description 添加一个模式串
     * @Author DFT
     * @Date 2020/5/24 0024
     * @Param [cs]
     * @return void
     **/
    public void addKeyword(CharSequence cs) {
        if (cs == null || cs.length() == 0) return;
        //  从根节点开始
        Node currentState = this.root;
        int len = cs.length();
        for (int i = 0; i < len; i++) {
            // 根据字符添加子节点并返回
            currentState = currentState.insert(cs.charAt(i));
        }
        // 将完整字符串添加到最后一个节点上
        currentState.addMatchInfo(cs);
    }

    /**
     * @Description  删除一个模式串
     * @Author DFT
     * @Date 2020/5/24 0024
     * @Param [cs]
     * @return void
     **/
    public void deleteKeyword(CharSequence cs){
        if (cs == null || cs.length() == 0) return;
        //  从根节点开始
        Node currentState = this.root;
        Node parent = this.root;
        int count = 0;
        int len = cs.length();
        for (int i = 0; i < len; i++) {
            currentState = currentState.childAt(cs.charAt(i));
            if(currentState==null) return;
            if(i==len-1) {
                if(!currentState.children().isEmpty()) return;
            } else if(currentState.children().size()>1 || (currentState.emit()!=null && !currentState.emit().isEmpty())) {
                parent = currentState;
                count = i + 1;
            }
        }
        parent.map.remove(cs.charAt(count));
    }

    /**
     * @Description 匹配模式串
     * @Author DFT
     * @Date 2020/5/24 0024
     * @Param [text]
     * @return java.util.Collection<com.dft.ACTrie.MatchInfo>
     **/
    public Collection<MatchInfo> search(String text) {
        if (!this.failureSetted) setFailNode();
        Node currentState = this.root;
        List<MatchInfo> matchInfos = new ArrayList<MatchInfo>();
        int len = text.length();
        for (int position = 0; position < len; position++) {
            Character character = text.charAt(position);
            currentState = currentState.nextNode(character);
            Collection<CharSequence> emits = currentState.emit();
            if (emits == null || emits.isEmpty()) {
                continue;
            }
            for (CharSequence emit : emits) {
                matchInfos.add(new MatchInfo(position - emit.length() + 1, position, emit));
            }
        }
        return matchInfos;
    }

    /**
     * @Description 判断是否存在匹配的字符串
     * @Author DFT
     * @Date 2020/5/24 0024
     * @Param [text]
     * @return boolean
     **/
    public boolean findAnyIn(String text){
        if (!this.failureSetted) setFailNode();
        boolean result = false;
        Node currentState = this.root;
        int len = text.length();
        for (int position = 0; position < len; position++) {
            Character c = text.charAt(position);
            currentState = currentState.nextNode(c);
            Collection<CharSequence> emits = currentState.emit();
            if (emits == null || emits.isEmpty()) {
                continue;
            }
            result = true;
        }
        return result;
    }

    /**
     * @Description 设置失败节点
     * @Author DFT
     * @Date 2020/5/24 0024
     * @Param []
     * @return void
     **/
    private void setFailNode() {
        //  创建一个队列
        Queue<Node> queue = new LinkedList<Node>();
        // 1.根节点的所有子节点失败节点都是根节点
        Collection<Node> rootChildren = this.root.children();
        for (Node rootChild : rootChildren) {
            // 设置失败节点为根节点
            rootChild.setFailure(this.root);
            // 将节点加入队列用于后续递归
            queue.add(rootChild);
        }
        // 使用广度优先搜索BFS，层次遍历节点来处理，每一个节点的失败路径
        while (!queue.isEmpty()) {
            // 从队列中取出一个节点作为父节点
            Node parentNode = queue.poll();
            // 获取该节点的所有子节点
            Collection<Node> children = parentNode.children();
            for (Node child : children) {
                queue.add(child);
                // 失败节点=父节点的失败节点的next节点
                Node failNode = parentNode.getFailure().nextNode(child.value);
                child.setFailure(failNode);
                child.addMatchInfo(failNode.emit());
            }
        }
        this.failureSetted = true;
    }

    private static class Node {
        private static final char EMPTY = '\0';
        private boolean isRoot = false;//是否为根结点
        private Map<Character, Node> map;//  子节点map
        private char value;// 节点的值
        private Node failure; // 失败节点
        private List<CharSequence> emits; // 输出

        public Node(char value) {
            this.value = value;
            map = new HashMap<Character, Node>();
            emits = new ArrayList<CharSequence>();
        }

        /**
         * @Description 通过带参数构造器创建根节点
         * @Author DFT
         * @Date 2020/5/24 0024
         * @Param [isRoot]
         * @return
         **/
        public Node(boolean isRoot) {
            this(EMPTY);
            this.isRoot = isRoot;
        }

        /**
         * @Description 根据字符添加子节点
         * @Author DFT
         * @Date 2020/5/24 0024
         * @Param [character]
         * @return com.dft.ACTrie.Node
         **/
        public Node insert(Character character) {
            //  先判断当前节点中是否包含目标字符的子节点
            Node node = this.map.get(character);
            if (node == null) {
                // 如果没有 创建一个新的节点
                node = new Node(character);
                // 添加到当前节点的map中
                map.put(character, node);
            }
            // 返回节点
            return node;
        }

        /**
         * @Description 根据给定字符获取子节点
         * @Author DFT
         * @Date 2020/5/24 0024
         * @Param [character]
         * @return com.dft.ACTrie.Node
         **/
        public Node childAt(Character character) {
            return map.get(character);
        }

        /**
         * @Description 根据给定字符跳转到下一个节点
         * @Author DFT
         * @Date 2020/5/24 0024
         * @Param [transition]
         * @return com.dft.ACTrie.Node
         **/
        private Node nextNode(Character c) {
            // 在子节点中获取next节点
            Node next = this.childAt(c);
            if (next != null) {
                return next;
            }
            //如果跳转到根结点还是失败，则返回根结点
            if (this.isRoot) {
                return this;
            }
            // 按失败节点递归
            return this.failure.nextNode(c);
        }

        public void addMatchInfo(CharSequence cs) {
            emits.add(cs);
        }

        public void addMatchInfo(Collection<CharSequence> keywords) {
            emits.addAll(keywords);
        }

        public Collection<Node> children() {
            return this.map.values();
        }

        public void setFailure(Node node) {
            failure = node;
        }

        public Node getFailure() {
            return failure;
        }

        public Collection<CharSequence> emit() {
            return this.emits == null ? Collections.<CharSequence>emptyList() : this.emits;
        }
    }

    private static class MatchInfo {
        private final CharSequence keyword;// 匹配到的模式串
        private final int start;
        private final int end;

        /**
         * 模式匹配结果
         */
        public MatchInfo(final int start, final int end, final CharSequence keyword) {
            this.start = start;
            this.end = end;
            this.keyword = keyword;
        }

        /**
         * 获取模式值
         * @return
         */
        public CharSequence getKeyword() {
            return this.keyword;
        }

        @Override
        public String toString() {
            return "MatchInfo{" +
                    "keyword=" + keyword +
                    ", start=" + start +
                    ", end=" + end +
                    '}';
        }
    }

    public static void main(String[] args) {
        List<String> keywords = Arrays.asList("coxquery#@{","coxquery#@config#@{","coxqueryhealth#@{","agent#@{","agent#@config#@{","agenthealth#@{");
        ACTrie trie = new ACTrie();
        trie.addKeyword("ctg#@{");
        trie.addKeyword("ctg#@config#@{");
        trie.addKeyword("ctghealth#@{");
        trie.addKeyword("cox#@{");
        trie.addKeyword("cox#@config#@{");
        trie.addKeyword("coxhealth#@{");
        trie.addKeywordList(keywords);

        trie.deleteKeyword("coxhealth#@{");
        System.out.println(trie.findAnyIn("#@monitor#@dataquery#@coxhealth#@{"));
        System.out.println(trie.findAnyIn("#@monitor#@dataquery#@cox#@config#@{"));
        Collection<MatchInfo> emits = trie.search("#@monitor#@dataquery#@coxquery#@config#@{");
        for (MatchInfo emit : emits) {
            System.out.println(emit);
        }
    }

}