帮我写一个java版的AC算法

好的，以下是一个简单的 Java 版本的 AC 算法实现：

import java.util.*;

class ACNode {
    public char ch;
    public boolean isEnd;
    public ACNode fail;
    public Map<Character, ACNode> children;

    public ACNode(char ch) {
        this.ch = ch;
        this.isEnd = false;
        this.fail = null;
        this.children = new HashMap<>();
    }
}

class ACAutomaton {
    private ACNode root;

    public ACAutomaton() {
        this.root = new ACNode('\0');
    }

    public void insert(String word) {
        ACNode node = root;
        for (char ch : word.toCharArray()) {
            if (!node.children.containsKey(ch)) {
                node.children.put(ch, new ACNode(ch));
            }
            node = node.children.get(ch);
        }
        node.isEnd = true;
    }

    public void buildFail() {
        Queue<ACNode> queue = new LinkedList<>();
        for (ACNode child : root.children.values()) {
            child.fail = root;
            queue.offer(child);
        }
        while (!queue.isEmpty()) {
            ACNode node = queue.poll();
            for (ACNode child : node.children.values()) {
                ACNode failNode = node.fail;
                while (failNode != null && !failNode.children.containsKey(child.ch)) {
                    failNode = failNode.fail;
                }
                if (failNode == null) {
                    child.fail = root;
                } else {
                    child.fail = failNode.children.get(child.ch);
                }
                queue.offer(child);
            }
        }
    }

    public List<String> search(String text) {
        List<String> result = new ArrayList<>();
        ACNode node = root;
        for (int i = 0; i < text.length(); i++) {
            char ch = text.charAt(i);
            while (node != null && !node.children.containsKey(ch)) {
                node = node.fail;
            }
            if (node == null) {
                node = root;
            } else {
                node = node.children.get(ch);
            }
            if (node.isEnd) {
                result.add(text.substring(i - word.length() + 1, i + 1));
            }
        }
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        ACAutomaton ac = new ACAutomaton();
        ac.insert("he");
        ac.insert("she");
        ac.insert("his");
        ac.insert("hers");
        ac.buildFail();
        List<String> result = ac.search("ushers");
        System.out.println(result);
    }
}

这是一个简单的 AC 自动机实现，可以用于多模式匹配。我们首先定义了一个 ACNode 类，表示 AC 自动机的节点，包含了节点的字符、是否为单词结尾、失败指针以及子节点等信息。然后定义了一个 ACAutomaton 类，表示 AC 自动机本身，包含了根节点、插入单词、构建失败指针、搜索等操作。在主函数中，我们插入了一些单词，构建了 AC 自动机，然后在一个字符串中搜索这些单词，输出匹配结果。

希望这个实现对你有所帮助！