【java必修课】判断string是否包含子串的四种方法及性能对比

在Java中，判断一个字符串是否包含另一个字符串是经常使用的一项操作。本文将介绍四种常见的方法来判断字符串是否包含子串，并对它们的性能进行对比。

方法一：使用contains()方法

Java中String类提供了contains()方法，用于判断一个字符串是否包含另一个字符串。

String str = "Hello World";
if (str.contains("World")){
    // 包含子串
}

这种方法非常容易使用而且看起来简洁明了。

方法二：使用indexOf()方法

另一个常见的方法是使用String类的indexOf()方法。在找到子串的位置后，该方法返回子串在字符串中的位置，或者-1如果没有找到。因此，我们可以通过检查indexOf()的结果是否为-1来确定子串是否存在。

String str = "Hello World";
if (str.indexOf("World") != -1) {
    //包含子串
}

在某些情况下，indexOf()的性能可能更好，因为这是一个更基本的操作。而contains()方法实际上是一个更通用的方法，可以查找更复杂的模式。

方法三：使用Pattern和Matcher

Java中提供了Pattern和Matcher类，可以使用正则表达式来查找字符串中的子串。

String str = "Hello World";
Pattern pattern = Pattern.compile("World");
Matcher matcher = pattern.matcher(str);
if (matcher.find()){
    // 包含子串
}

这种方法可能会更加灵活，但是它也更加复杂，需要更多的代码。如果您需要在字符串中搜索较为复杂的模式，那么使用正则表达式来进行搜索是非常有用的。

方法四：使用StringTokenizer

最后，还可以使用Java中的StringTokenizer类。该类将一个字符串分解为子字符串，并可以在每个子字符串上执行操作。使用StringTokenizer，您可以逐个查找子串，然后检查它们是否与您想要查找的子串匹配。

String str = "Hello World";
StringTokenizer st = new StringTokenizer(str);
while (st.hasMoreTokens()) {
    String token = st.nextToken();
    if (token.equals("World")) {
        // 包含子串
    }
}

与前面几种方法相比，这种方法可能会更加复杂，但是它可以处理更多的情况。

性能对比

我们使用Java自带的System.currentTimeMillis()方法来对四种方法的性能进行测试，并进行对比。

public static void main(String[] args) {
    int times = 100000;
    String str = "Hello World";

    //方法一：使用contains()方法
    long start = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        if (str.contains("World")) {
        }
    }
    long end = System.currentTimeMillis();
    System.out.println("contains()方法耗时：" + (end - start) + "ms");

    //方法二：使用indexOf()方法
    start = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        if (str.indexOf("World") != -1) {
        }
    }
    end = System.currentTimeMillis();
    System.out.println("indexOf()方法耗时：" + (end - start) + "ms");

    //方法三：使用Pattern和Matcher
    Pattern pattern = Pattern.compile("World");
    Matcher matcher;
    start = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        matcher = pattern.matcher(str);
        if (matcher.find()) {
        }
    }
    end = System.currentTimeMillis();
    System.out.println("Pattern和Matcher方法耗时：" + (end - start) + "ms");

    //方法四：使用StringTokenizer
    StringTokenizer st;
    start = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        st = new StringTokenizer(str);
        while (st.hasMoreTokens()) {
            String token = st.nextToken();
            if (token.equals("World")) {
            }
        }
    }
    end = System.currentTimeMillis();
    System.out.println("StringTokenizer方法耗时：" + (end - start) + "ms");
}

通过以上测试代码，我们可以得到执行100,000次判断的结果：

• contains()方法耗时：5ms
• indexOf()方法耗时：6ms
• Pattern和Matcher方法耗时：62ms
• StringTokenizer方法耗时：65ms

由此可见，contains()方法和indexOf()方法既容易使用又性能不错，因此在日常使用中我们应该优先考虑这两种方法。如果我们需要在字符串中查找复杂的模式，那么使用正则表达式是一个不错的选择，但同时需要注意正则表达式的性能问题。而StringTokenizer类则更适用于处理较为复杂的情况。

在实际应用中，我们应根据不同的需求，灵活选择字符串查找方法，以取得最优雅的代码并不必要牺牲性能。