我正在尝试创建一个程序，以尽可能快地检测字符串中是否有多个单词，如果是，则执行一个行为。最好，我也希望它能够检测这些单词的顺序，但前提是这可以快速完成。到目前为止，这就是我所做的：
if (input.contains("adsf") && input.contains("qwer")) {
execute();
}
如您所见，对多个单词执行此操作会变得很烦人。这是唯一的方法还是有更好的方法来检测多个子字符串？有什么方法可以检测顺序吗？
【问题讨论】：
标签： java string substring contains
我会根据这些词创建一个正则表达式：
Pattern pattern = Pattern.compile("(?=.*adsf)(?=.*qwer)");
if (pattern.matcher(input).find()) {
execute();
}
更多详情请看这个答案：https://stackoverflow.com/a/470602/660143
【讨论】：
编者注：尽管被大力支持和接受，但它的功能与问题中的代码不同。
execute在第一次匹配时被调用，就像一个逻辑 OR。
你可以使用数组：
String[] matches = new String[] {"adsf", "qwer"};
bool found = false;
for (String s : matches)
{
if (input.contains(s))
{
execute();
break;
}
}
这与您发布的一样有效，但更易于维护。寻找更有效的解决方案听起来像是一种微优化，在被证明是代码的有效瓶颈之前应该忽略它，在任何情况下，如果字符串集很大，该解决方案可能会是一个尝试。
【讨论】：
在 Java 8 中你可以这样做
public static boolean containsWords(String input, String[] words) {
return Arrays.stream(words).allMatch(input::contains);
}
示例用法：
String input = "hello, world!";
String[] words = {"hello", "world"};
if (containsWords(input, words)) System.out.println("Match");
【讨论】：
如果您有很多子字符串要查找，那么正则表达式可能不会有太大帮助，因此您最好将子字符串放在一个列表中，然后遍历它们并调用 input.indexOf(substring)在每一个上。这将返回找到子字符串的位置的int 索引。如果您将每个结果（-1 除外，这意味着未找到子字符串）放入 TreeMap（其中 index 是键，子字符串是值），那么您可以通过调用按顺序检索它们keys() 在地图上。
Map<Integer, String> substringIndices = new TreeMap<Integer, String>();
List<String> substrings = new ArrayList<String>();
substrings.add("asdf");
// etc.
for (String substring : substrings) {
int index = input.indexOf(substring);
if (index != -1) {
substringIndices.put(index, substring);
}
}
for (Integer index : substringIndices.keys()) {
System.out.println(substringIndices.get(index));
}
【讨论】：
使用树结构来保存每个代码点的子字符串。这样就不需要
请注意，这只有在针组几乎恒定时才有效。虽然单独添加或删除子字符串并不是低效的，但是每次将大量字符串排列成树结构时进行不同的初始化肯定会减慢它。
StringSearcher:import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
class StringSearcher{
private NeedleTree needles = new NeedleTree(-1);
private boolean caseSensitive;
private List<Integer> lengths = new ArrayList<>();
private int maxLength;
public StringSearcher(List<String> inputs, boolean caseSensitive){
this.caseSensitive = caseSensitive;
for(String input : inputs){
if(!lengths.contains(input.length())){
lengths.add(input.length());
}
NeedleTree tree = needles;
for(int i = 0; i < input.length(); i++){
tree = tree.child(caseSensitive ? input.codePointat(i) : Character.toLowerCase(input.codePointAt(i)));
}
tree.markSelfSet();
}
maxLength = Collections.max(legnths);
}
public boolean matches(String haystack){
if(!caseSensitive){
haystack = haystack.toLowerCase();
}
for(int i = 0; i < haystack.length(); i++){
String substring = haystack.substring(i, i + maxLength); // maybe we can even skip this and use from haystack directly?
NeedleTree tree = needles;
for(int j = 0; j < substring.maxLength; j++){
tree = tree.childOrNull(substring.codePointAt(j));
if(tree == null){
break;
}
if(tree.isSelfSet()){
return true;
}
}
}
return false;
}
}
NeedleTree.java:import java.util.HashMap;
import java.util.Map;
class NeedleTree{
private int codePoint;
private boolean selfSet;
private Map<Integer, NeedleTree> children = new HashMap<>();
public NeedleTree(int codePoint){
this.codePoint = codePoint;
}
public NeedleTree childOrNull(int codePoint){
return children.get(codePoint);
}
public NeedleTree child(int codePoint){
NeedleTree child = children.get(codePoint);
if(child == null){
child = children.put(codePoint, new NeedleTree(codePoint));
}
return child;
}
public boolean isSelfSet(){
return selfSet;
}
public void markSelfSet(){
selfSet = true;
}
}
【讨论】：
这是一个经典的面试和 CS 问题。
Robin Karp 算法通常是人们在采访中首先谈论的内容。基本思想是，在遍历字符串时，将当前字符添加到散列中。如果哈希与您的一个匹配字符串的哈希匹配，则您知道您可能有一个匹配项。这避免了在匹配字符串中来回扫描。 https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm
该面试问题的其他典型主题是考虑使用 trie 结构来加快查找速度。如果您有大量匹配字符串，则必须始终检查大量匹配字符串。 trie 结构更有效地进行检查。 https://en.wikipedia.org/wiki/Trie
其他算法有： - 阿霍-科拉西克https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm - Commentz-Walter https://en.wikipedia.org/wiki/Commentz-Walter_algorithm
【讨论】：
我认为更好的方法是这样的，我们可以将多个值添加为一个字符串并通过函数索引验证索引
String s = "123";
System.out.println(s.indexOf("1")); // 0
System.out.println(s.indexOf("2")); // 1
System.out.println(s.indexOf("5")); // -1
【讨论】：