一、背景

需求非常簡單，給定一組關鍵詞，需要將商品名稱中出現過的關鍵字替換掉；

如：skuName="HUAWEI Pura 70 Pro 國家補貼500元 羽砂黑 12GB+512GB 超高速風馳閃拍 華為鴻蒙智能手機" 需要替換成

skuName="HUAWEI Pura 70 Pro 羽砂黑 12GB+512GB 超高速風馳閃拍 華為鴻蒙智能手機" 這里的關鍵字"國家補貼500元";

直接skuName.replace("國家補貼500元", "")，不就可以了嗎？如果是一組，那就循環替換就完了嘛，再考慮到關鍵字前綴問題，對這一組關鍵詞，按字符長度進行排序，先替換長的關鍵詞，再替換短的就ok了；

如果這一組關鍵詞非常多，上千個怎么辦？真實場景也是這樣的，一般需要替換的關鍵詞都是比較多，并且使用String.replace上線后，直接CPU打滿，基本不可用；

這個字段替換本質上與敏感詞過濾是一樣的原理，針對敏感詞的深入研究，出現了 Aho-Corasick（AC自動機） 算法；

Aho-Corasick（AC自動機）是一種多模式字符串匹配算法，結合了Trie樹的前綴匹配能力和KMP算法的失敗跳轉思想，能夠在單次文本掃描中高效匹配多個模式串。其核心優勢在于時間復雜度為O(n + m + z)（n為文本長度，m為模式串總長度，z為匹配次數），適用于敏感詞過濾、基因序列分析等場景。

?

二、方案

針對這幾種算法進行對比；

字符串替換，定義一個接口，通過4個不同的方案實現，進行性能對比

public interface Replacer {
    String replaceKeywords(String text);
}

2.1 String.replace 方案

這種方案最簡單，也是關鍵詞少的時候，最有效，最好用的;

public class StrReplacer implements Replacer {
    private final List keyWordList;
    public StrReplacer(String keyWords) {
        this.keyWordList = Lists.newArrayList(keyWords.split(";"));
        // 按關鍵字長度降序排序，確保長關鍵字優先匹配
        keyWordList.sort((a, b) -> Integer.compare(b.length(), a.length()));
    }
    /**
    * 替換文本中所有匹配的關鍵字為空字符串
    */
    @Override
    public String replaceKeywords(String text) {
        String newTxt = text;
        for (String s : keyWordList) {
            newTxt = newTxt.replace(s, "");
        }
        return newTxt;
    }
}

2.2 使用正則替換

String.replace本質，還是使用正則進行替換的，通過代碼實現使用編譯好的正則進行替換性能會好于直接使用replace；

String.replace的實現

public String replace(CharSequence target, CharSequence replacement) {
    return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
            this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}

使用正則替換的實現

public class PatternReplacer implements Replacer {
    // 預編譯正則表達式模式
    private final Pattern pattern;
    public PatternReplacer(String keyWords) {
        List keywords = Lists.newArrayList(keyWords.split(";"));
        // 按關鍵字長度降序排序，確保長關鍵字優先匹配
        keywords.sort((a, b) -> Integer.compare(b.length(), a.length()));
        // 轉義每個關鍵字并用|連接
        String regex = keywords.stream()
                .map(Pattern::quote)
                .collect(Collectors.joining("|"));

        this.pattern = Pattern.compile(regex);
    }

    // 替換方法
    @Override
    public String replaceKeywords(String skuName) {
        return pattern.matcher(skuName).replaceAll("");
    }
}

2.3 使用Aho-Corasick（AC自動機） 算法實現

在java中已有現成的算法實現，源代碼github-robert-bor/aho-corasick，?

引入jar包

    org.ahocorasick
    ahocorasick
    0.6.3

基于 Aho-Corasick 算法的字符串替換實現

public class AhoCorasickReplacer implements Replacer {
    private final Trie trie;
    public AhoCorasickReplacer(String keyWords) {
        // 構建Aho-Corasick自動機
        Trie.TrieBuilder builder = Trie.builder().ignoreOverlaps().onlyWholeWords();
        //trie.caseInsensitive();
        //trie.onlyWholeWords();
        for (String s : keyWords.split(";")) {
            builder.addKeyword(s);
        }
        this.trie = builder.build();
    }
    /**
     * 替換文本中所有匹配的關鍵字為空字符串
     */
    @Override
    public String replaceKeywords(String text) {
        if (text == null || text.isEmpty()) {
            return text;
        }
        StringBuilder result = new StringBuilder();
        Collection emits = trie.parseText(text); // 獲取所有匹配結果
        int lastEnd = 0;
        for (Emit emit : emits) {
            int start = emit.getStart();
            int end = emit.getEnd();

            // 添加未匹配的前綴部分
            if (start > lastEnd) {
                result.append(text, lastEnd, start);
            }
            // 跳過匹配的關鍵字（即替換為空）
            lastEnd = end + 1; // 注意：end是閉區間，需+1移動到下一個字符
        }
        // 添加剩余未匹配的后綴部分
        if (lastEnd <= text.length() - 1) {
            result.append(text.substring(lastEnd));
        }
        return result.toString();
    }
}

2.4 自己實現Trie樹算法實現

通過deepseek等人工智能，是非常容易自己實現一個Trie樹，我們就只實現字符串替換的功能，其他的就不使用了；

Trie樹，又叫字典樹，前綴樹(Prefix Tree)，單詞查找樹，是一種多叉樹的結構.

結構說明： 表示根節點（空節點）

每個節點表示一個字符

粉色節點表示單詞結束標記（使用 CSS class 實現）

路徑示例：

root → c → a → t 組成 "cat"

root → c → a → r 組成 "car"

root → d → o → g 組成 "dog"

public class TrieKeywordReplacer implements Replacer {

    private final Trie trie;

    @Override
    public String replaceKeywords(String text) {
        return trie.replaceKeywords(text, "");
    }

    public TrieKeywordReplacer(String keyWords) {
        Trie trie = new Trie();
        for (String s : keyWords.split(";")) {
            trie.insert(s);
        }
        this.trie = trie;
    }

    static class TrieNode {
        Map children;
        boolean isEndOfWord;

        public TrieNode() {
            children = new HashMap();
            isEndOfWord = false;
        }
    }

    static class Trie {
        private TrieNode root;

        public Trie() {
            root = new TrieNode();
        }

        private synchronized void insert(String word) {
            TrieNode node = root;
            for (char c : word.toCharArray()) {
                if (node.children.get(c) == null) {
                    node.children.put(c, new TrieNode());
                }
                node = node.children.get(c);
            }
            node.isEndOfWord = true;
        }

        public String replaceKeywords(String text, String replacement) {
            StringBuilder result = new StringBuilder();
            int i = 0;
            while (i < text.length()) {
                TrieNode node = root;
                int j = i;
                TrieNode endNode = null;
                int endIndex = -1;
                while (j < text.length() && node.children.get(text.charAt(j)) != null) {
                    node = node.children.get(text.charAt(j));
                    if (node.isEndOfWord) {
                        endNode = node;
                        endIndex = j;
                    }
                    j++;
                }
                if (endNode != null) {
                    result.append(replacement);
                    i = endIndex + 1;
                } else {
                    result.append(text.charAt(i));
                    i++;
                }
            }
            return result.toString();
        }
    }
}

4個實現類對象的大小對比

性能對比

說明：待替換一組關鍵詞共 400個；JDK1.8

?

通過性能對比，自己實現的Trie樹的性能是最好的，因為只做了替換的邏輯，沒有實現其他功能，其次是使用AhoCorasick算法，因為使用 AhoCorasick算法，實現字符串替換是最基本的功能，AhoCorasick算法，還能精準的匹配到在什么地方，出現過多少次等信息，功能非常強大；

通過對比編譯好的正則性能確實是比使用原生String.replace;

public class ReplacerTest {

    @Test
    public void testTrieKeywordReplacer(){
        //String name = skuName;
        //String expected = v2;
        //String name = "三星Samsung Galaxy S25+ 超擬人AI助理 驍龍8至尊版 AI拍照 翻譯手機 游戲手機 12GB+256GB 冷川藍";
        //String expected = name;

        String name = keyWords;
        String expected = v1;
        int cnt = 2;
        Replacer replacer = new TrieKeywordReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }
    }

    @Test
    public void 替換所有關鍵字() throws InterruptedException {
        //String name = skuName;
        //String expected = v2;
        //String name = "三星Samsung Galaxy S25+ 超擬人AI助理 驍龍8至尊版 AI拍照 翻譯手機 游戲手機 12GB+256GB 冷川藍";
        //String expected = name;

        String name = keyWords;
        String expected = v1;

        int cnt = 2;
        System.out.println("替換：" + name);
        Replacer replacer = new StrReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }


        replacer = new PatternReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }

        replacer = new TrieKeywordReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }

        replacer = new AhoCorasickReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }



    }


    @Test
    public void 無關鍵字替換() throws InterruptedException {
        //String name = skuName;
        //String expected = v2;
        String name = "三星Samsung Galaxy S25+ 超擬人AI助理 驍龍8至尊版 AI拍照 翻譯手機 游戲手機 12GB+256GB 冷川藍";
        String expected = name;

        //String name = keyWords;
        //String expected = v1;

        int cnt = 1;
        System.out.println("替換：" + name);
        Replacer replacer = new StrReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }


        replacer = new PatternReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }

        replacer = new TrieKeywordReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }

        replacer = new AhoCorasickReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }



    }

    @Test
    public void 有1個關鍵字替換() throws InterruptedException {
        //String name = skuName;
        //String expected = v2;
        //String name = "三星Samsung Galaxy S25+ 超擬人AI助理 驍龍8至尊版 AI拍照 翻譯手機 游戲手機 12GB+256GB 冷川藍";
        //String expected = name;

        //String name = keyWords;
        //String expected = v1;

        String name = "HUAWEI Pura 70 Pro 國家補貼500元 羽砂黑 12GB+512GB 超高速風馳閃拍 華為鴻蒙智能手機";
        String expected = "HUAWEI Pura 70 Pro 500元 羽砂黑 12GB+512GB 超高速風馳閃拍 華為鴻蒙智能手機";

        int cnt = 1;
        System.out.println("替換：" + name);
        Replacer replacer = new StrReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }


        replacer = new PatternReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }

        replacer = new TrieKeywordReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }

        replacer = new AhoCorasickReplacer(keyWords);
        check(replacer, name, expected);
        for (int i = 0; i < cnt; i++) {
            checkExec(replacer, name);
        }



    }


    static void check(Replacer replacer, String name, String expected) {
        System.out.println(replacer.getClass().getName()+"，對象大小："+ObjectSizeCalculator.getObjectSize(replacer));
        String newTxt = replacer.replaceKeywords(name);
        //System.out.println(newTxt);
        Assert.assertEquals(replacer.getClass().getName() + ",對比不一致!", expected, newTxt);
    }


    void checkExec(Replacer replacer, String name) {
        String newTxt = replacer.replaceKeywords(name);
        int nThreads  = 2;
        ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
        CountDownLatch downLatch = new CountDownLatch(nThreads);
        int i = 0;
        while (i++ < nThreads) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    int i = 0;
                    long ns = System.nanoTime();
                    while (i++ < 100000) {
                        replacer.replaceKeywords(name);
                    }
                    String name = replacer.getClass().getName();
                    downLatch.countDown();
                    System.out.println(StringUtils.substring(name, name.length() - 50, name.length()) + "ti=" + i + ", t耗時：" + (System.nanoTime() - ns) / i + "ns");
                }
            });
        }
        executorService.shutdown();
        try {
            downLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

最后

1、使用現成的AhoCorasick算法進行實現，是性能與穩定性最優的選擇，非常強調性能，還是可以自己實現Trie樹來實現；

2、在真實的使用過程中，因為大部分的商品名稱最多出現幾個關鍵詞，并且待替換的關鍵詞往往都是比較多的，可以將這么關鍵詞找出找出幾個有代表性能的詞，做前置判斷，商品名稱中是否存在；再進行全量替換；

如待替換的關鍵詞有：政府補貼、國補、支持國補； 那么我們并不是直接就循環這個待替換的關鍵詞組，而是找出這么關鍵詞中都有的關鍵字”補”先判斷商品名稱中是否存在“補”字后，再做處理; 這里的前置判斷，還可以使用布隆過濾器實現；

public String replaceKeywords (String skuName){
    Replacer replacer = new AhoCorasickReplacer(keyWords);
    if(skuName.contains("補")){
        return  replacer.replaceKeywords(skuName);
    } else {
        return skuName;
    }
}

參考

- [1] Aho-Corasick 算法 AC自動機實現?

- [2] Trie字典樹?

審核編輯 黃宇