检索字符串中的关键词方式有哪些？

1. 简介

在本文中，我们将了解如何检测字符串中的多个单词。

2. 我们的例子

我们假设我们有字符串：

String inputString = "hello there, Baeldung";

我们的任务是查找inputString 是否包含“hello”和“Baeldung”字样。

所以，让我们把我们的关键字放到一个数组中：

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

此外，单词的顺序并不重要，匹配应区分大小写。

3. 使用String.contains（）

首先，我们将展示如何使用String.contains（）方法来实现我们的目标。

让我们遍历关键字数组并检查inputString中每个item的出现：

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

如果inputString包含指定的item，contains（）方法将返回真。当我们的字符串中没有任何关键字时，我们可以停止向前移动并立即返回false。

尽管我们需要编写较多代码，但这种解决方案对于简单的用例来说速度很快。

4.使用 String.indexOf（）

与使用String.contains（）方法的解决方案类似，我们可以使用String.indexOf（）方法检查关键字的索引。为此，我们需要一个接受inputString和words数组的方法：

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（）方法返回的word在inputString中的索引。当我们在文本中没有单词时，索引将为-1。

5.使用正则表达式

现在，让我们使用正则表达式来匹配我们的单词。为此，我们将使用Pattern类。

首先，让我们定义字符串表达式。由于我们需要匹配两个关键字，我们将使用两个构建我们的正则表达式规则：

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

对于一般情况：

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();
}

但是，正则表达式具有性能成本。如果我们要查找多个单词，则此解决方案的性能可能不是最佳的。

6.使用Java 8和List

最后，我们可以使用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);
}

但是，此方法仅适用于整个单词。因此，只有当它们与文本中的空格分开时才会找到我们的关键字。

7.使用Aho-Corasick算法

简而言之，Aho-Corasick算法用于使用多个关键字进行文本搜索。无论我们搜索多少关键字或文本长度是多长，它都具有O（n）时间复杂度。

让我们在pom.xml中包含Aho-Corasick算法依赖：


    org.ahocorasick
    ahocorasick
    0.4.0

首先，让我们构建pipeline的关键字阵列。为此，我们将使用Trie数据结构：

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

之后，让我们使用inputString文本调用解析器方法，我们希望在其中找到关键字并将结果保存在emits集合中：

Collection emits = trie.parseText(inputString);

最后，如果我们打印我们的结果：

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

对于每个关键字，我们会在文本中查看关键字的起始位置，结束位置和关键字本身：

0:4=hello
13:20=Baeldung

最后，让我们看看完整的实现：

public static boolean ahoCorasick(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集合中删除重复元素，因为同一关键字可能存在多个匹配项。

8.结论

在本文中，我们学习了如何在字符串中查找多个关键字。此外，我们通过使用核心JDK以及Aho-Corasick库来展示示例。

每日福利

欢迎大家关注公众号：「Java知己」，关注公众号，回复「1024」你懂得，免费领取 30 本经典编程书籍。关注我，与 10 万程序员一起进步。每天更新Java知识哦，期待你的到来！

image