摘要：簡介在本快速教程中，將了解如何檢測字符串中的多個單詞。我們的例子我們假設我們有字符串我們的任務是查找是否包含和字樣。使用與使用方法的解決方案類似，我們可以使用方法檢查關鍵字的索引。結論在本文中，我們學習了如何在字符串中查找多個關鍵字。

在本快速教程中，將了解如何檢測字符串中的多個單詞。

我們假設我們有字符串：

String inputString = "hello there, william";

我們的任務是查找inputString 是否包含“hello”和“william”字樣。

所以，讓我們把我們的關鍵字放到一個數組中：

String[] words = {"hello", "william"};

此外，單詞的順序并不重要，匹配要區分大小寫。

首先，我們將展示如何使用String.contains()方法來實現我們的目標。

讓我們遍歷關鍵字數組并檢查inputString中每個項目的出現 ：

public static boolean containsWords(String inputString, String[] items) {
    boolean found = true;
    for (String item : items) {
        if (!inputString.contains(item)) {
            found = false;
            break;
        }
    }
    return found;
}

這個例子比較簡單易懂，盡管我們需要編寫更多代碼，但這種解決方案對于簡單的用例來說速度很快。

與使用String.contains()方法的解決方案類似，我們可以使用String.indexOf()方法檢查關鍵字的索引。為此，我們需要一個接受inputString和關鍵字列表的方法：

public static boolean containsWordsIndexOf(String inputString, String[] words) {
    boolean found = true;
    for (String word : words) {
        if (inputString.indexOf(word) == -1) {
            found = false;
            break;
        }
    }
    return found;
}

所述的indexOf() 方法返回的內部的字的索引inputString。當我們在文本中沒有單詞時，索引將為-1。

現在，讓我們使用正則表達式來匹配我們的單詞。為此，我們將使用Pattern類。

首先，讓我們定義字符串表達式。由于我們需要匹配兩個關鍵字，我們將使用兩個前瞻構建我們的正則表達式規則：

Pattern pattern = Pattern.compile("(?=.*hello)(?=.*william)");

對于一般情況：

StringBuilder regexp = new StringBuilder();
for (String word : words) {
    regexp.append("(?=.*").append(word).append(")");
}

之后，我們將使用matcher()方法find()出現次數：

public static boolean containsWordsPatternMatch(String inputString, String[] words) {
 
    StringBuilder regexp = new StringBuilder();
    for (String word : words) {
        regexp.append("(?=.*").append(word).append(")");
    }
 
    Pattern pattern = Pattern.compile(regexp.toString());
 
    return pattern.matcher(inputString).find();
}

但是，正則表達式具有性能成本。如果我們要查找多個單詞，則此解決方案的性能可能不是最佳的。

最后，我們可以使用Java 8的Stream API。但首先，得把初始數據進行一些簡單的轉換：

List inputString = Arrays.asList(inputString.split(" "));
List words = Arrays.asList(words);

現在，是時候使用Stream API了：

public static boolean containsWordsJava8(String inputString, String[] words) {
    List inputStringList = Arrays.asList(inputString.split(" "));
    List wordsList = Arrays.asList(words);
 
    return wordsList.stream().allMatch(inputStringList::contains);
}

如果輸入字符串包含我們所有的關鍵字，則上面的操作將返回true。

或者，我們可以簡單地使用Collections框架的containsAll()方法來實現所需的結果：

public static boolean containsWordsArray(String inputString, String[] words) {
    List inputStringList = Arrays.asList(inputString.split(" "));
    List wordsList = Arrays.asList(words);
 
    return inputStringList.containsAll(wordsList);
}

但是，此方法僅適用于整個單詞。因此，只有當它們與文本中的空格分開時才會找到我們的關鍵字。

簡而言之，Aho-Corasick算法用于使用多個關鍵字進行文本搜索。無論我們搜索多少關鍵字或文本長度是多長，它都具有O(n)時間復雜度

讓我們在pom.xml中包含??Aho-Corasick算法依賴：

    org.ahocorasick
    ahocorasick
    0.4.0

首先，通過maven引入依賴包，內部的結構，將使用樹形數據結構：

Trie trie = Trie.builder().onlyWholeWords().addKeywords(words).build();

之后，讓我們使用inputString文本調用解析器方法，我們希望在其中找到關鍵字并將結果保存在emits集合中：

Collection emits = trie.parseText(inputString);

最后，打印運行的結果：

emits.forEach(System.out::println);

對于每個關鍵字，我們會在文本中查看關鍵字的起始位置，結束位置和關鍵字本身：

0:4=hello
13:19=william

最后，讓我們看看完整的實現：

public static boolean containsWordsAhoCorasick(String inputString, String[] words) {
    Trie trie = Trie.builder().onlyWholeWords().addKeywords(words).build();
 
    Collection emits = trie.parseText(inputString);
    emits.forEach(System.out::println);
 
    boolean found = true;
    for(String word : words) {
        boolean contains = Arrays.toString(emits.toArray()).contains(word);
        if (!contains) {
            found = false;
            break;
        }
    }
 
    return found;
}

在這個例子中，我們只尋找整個單詞。因此，如果我們不僅要匹配inputString而且還要匹配 helloBaeldung，我們應該簡單地從Trie構建器管道中刪除 onlyWholeWords()屬性。

此外，請記住，我們還會從emits集合中刪除重復元素，因為同一關鍵字可能存在多個匹配項。

在本文中，我們學習了如何在字符串中查找多個關鍵字。此外，我們通過使用核心JDK以及Aho-Corasick庫來展示示例。