我们可以直接在java中检查一组子字符串是否存在于较大的字符串中吗

前。 .com出现在amazon.com中 对于包含相反顺序的功的 它检查“amazon.com”。包含（“.com”） 但我需要找到它 .com是否包含在amazon.com中

---

因为我有一个要检查的（.com、.org等）值列表

使用regex

当最后一个字符串匹配时，它将为真

    String str = "amazon.com";
    System.out.println(str.matches(".*(com|org|in)"));

---

我想你想要这样的东西：

private boolean checkUrl(String url, List<String> suffixes) {
    boolean isValid = false;
    //Loop through all the correct suffixes
    for(String suffix : suffixes) {
        //If the suffix exists then we can set the variable to true and break the loop so we can return true.
        if(url.endsWith(suffix)) {
            isValid = true;
            break;
        }
    }

    return isValid;
}

public static boolean hasAny(String text, String[] values)
{
    for (String value : values)
    {
        if (text.contains(value))
            return true;
    }
    return false;
}

private boolean checkUrl（字符串url，列表后缀）{
布尔值isValid=false；
//循环遍历所有正确的后缀
for（字符串后缀：后缀）{
//如果后缀存在，那么我们可以将变量设置为true并中断循环，以便返回true。
if（url.endsWith（后缀））{
isValid=true；
打破
}
}
返回有效；
}

一种方法是将搜索算法拆分为如下内容：

convert
[".com", ".org"]
to
[
    '.': [
        'c': [
            'o': [
                'm': []
            ]
        ],
        'o': [
            'r': [
                'g': []
            ]
        ]
    ]
]

然后，您可以循环输入字符串中的所有字符，并找到单个字符的字符树。 然后你可以走到树的末尾，当你在某个点上找到一个空地图时，你已经找到了一个匹配项。如果你根本没有找到一个地图，那么它就不是一个匹配项

这个类将编译搜索树，并有一个与某些输入匹配的方法

public class CharSearch
{
    private final Map<Character, CharSet> charSets;

    public CharSearch(String[] values)
    {
        charSets = new HashMap<>();
        for (String value : values)
            addValue(value);
    }

    public void addValue(String value)
    {
        addValue(value.toCharArray(), 0);
    }

    public void addValue(char[] value, int index)
    {
        if (value == null || value.length == 0)
            return;

        CharSet charSet = charSets.computeIfAbsent(value[index], k -> new CharSet());
        charSet.addValue(value, index +1);
    }

    public String toString()
    {
        return getClass().getName() + charSets.toString();
    }

    public int match(String input)
    {
        char[] characters = input.toCharArray();
        for (int i = 0; i < characters.length; i++)
        {
            CharSet charSet = charSets.get(characters[i]);
            if (charSet != null)
            {
                if (charSet.match(characters, i) >= 0)
                    return i;
                else
                    break;
            }
        }
        return -1;
    }
}

class CharSet
{
    final Map<Character, CharSet> nextChars;
    boolean isLocked = false;

    CharSet()
    {
        this.nextChars = new HashMap<>();
    }

    public String toString()
    {
        return nextChars.toString();
    }

    void addValue(char[] value, int index)
    {
        if (isLocked)
            return;
        if (value.length <= index)
        {
            isLocked = true;
            nextChars.clear();
            return;
        }

        CharSet charSet = nextChars.computeIfAbsent(value[index], k -> new CharSet());
        charSet.addValue(value, index +1);
    }

    int match(char[] input, int index)
    {
        if (nextChars.isEmpty())
            return index;

        index++;
        if (input.length <= index)
            return -1;

        CharSet charSet = nextChars.get(input[index]);
        if (charSet != null)
        {
            return (charSet.match(input, index));
        }
        return -1;
    }
}

这将打印出“6”和“-1”

我假设要检查的值很少（本例中为2），这将比实际执行以下简单操作慢：

private boolean checkUrl(String url, List<String> suffixes) {
    boolean isValid = false;
    //Loop through all the correct suffixes
    for(String suffix : suffixes) {
        //If the suffix exists then we can set the variable to true and break the loop so we can return true.
        if(url.endsWith(suffix)) {
            isValid = true;
            break;
        }
    }

    return isValid;
}

public static boolean hasAny(String text, String[] values)
{
    for (String value : values)
    {
        if (text.contains(value))
            return true;
    }
    return false;
}

但是检查的值越多，SearchChar方法的效率就越高，而hasAny（）方法的效率就越低。 （请注意，效率的提高并不意味着运行时会下降。）

通过将只有一个子集的集合映射到一起，可以优化此算法：

[
    '.': [
        'com': [],
        'org': []
    ]
]

或者通过添加一个长度检查，将每个树的最小长度与正在计算的字符串的剩余长度（char[]）进行比较

或者跳过多个具有高智能预测的字符

但这应该足够玩了；）

编辑： 当你的所有输入（例如）都以一个点开始时，这里的效率就来了。 在简单检查中，需要O（n*t），其中n是输入中的字符数，t是检查以查找匹配的起始字符的值数

在CharSearch中，需要O（n）才能找到匹配项的起始字符。 最后的复杂度为O（n*（1~L）），其中L是您输入的值的最大长度…如果我没有弄错的话，这与String.contains（）的复杂度相同

---

（虽然大O符号可能不是正确的符号，但我认为对理解它的人来说应该非常清楚。）

String#endsWith

？为什么那是contains（）检查不是你的答案？

“amazon.com”。contains（.com）

完全符合你想要的字符串的相反方向。endsWith（）可以检查特定的值。。。我有一组值，比如.com、.org、.in等等。。。我需要找到包含这些值的字符串，如果这些值增加，值就无关紧要了，它将始终检查大括号（com | org | in）中的最后一个结束字符串。这非常慢，因为你需要检查1M的值