如果考虑性能的话，Java 中字符串模式匹配的最佳方法

Question

您好，

假设您想测试一个字符串以查看它是否完全匹配，或者是否与 _ 以及 _ 后面附加的任意数量的字符匹配

。 有效匹配示例：

MyTestString
MyTestString_
MyTestString_1234

如果性能是一个巨大的问题，哪些方法会你调查吗？目前我正在执行以下操作：

if (String.equals(stringToMatch)) {
            // success
        } else {
            if (stringToMatch.contains(stringToMatch + "_")) {
                // success
            }
            // fail
        }

我尝试用 _* 上的 Java.util.regex.Pattern 匹配替换 String.contains _ 模式，但效果更差。我的解决方案是否理想，或者您能想到更有效的方法来进一步提高性能吗？

感谢您的任何想法

Answer 1

你可以做类似的事情，

if(string.startsWith(testString)) {
    int len = testString.length();
    if(string.length() == len || string.charAt(len) == '_')
          // success
}

我假设你希望 testString 出现，即使你有一个“_”？

---

编辑：关于是否使用一个长条件或嵌套 if 语句，代码或性能没有差异。

public static void nestedIf(boolean a, boolean b) {
    if (a) {
        if (b) {
            System.out.println("a && b");
        }
    }
}

public static void logicalConditionIf(boolean a, boolean b) {
    if (a && b) {
        System.out.println("a && b");
    }
}

编译为相同的代码。如果你这样做 javap -c

public static void nestedIf(boolean, boolean);
  Code:
   0:   iload_0
   1:   ifeq    16
   4:   iload_1
   5:   ifeq    16
   8:   getstatic       #7; //Field java/lang/System.out:Ljava/io/PrintStream;
   11:  ldc     #8; //String a && b
   13:  invokevirtual   #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   16:  return

public static void logicalConditionIf(boolean, boolean);
  Code:
   0:   iload_0
   1:   ifeq    16
   4:   iload_1
   5:   ifeq    16
   8:   getstatic       #7; //Field java/lang/System.out:Ljava/io/PrintStream;
   11:  ldc     #8; //String a && b
   13:  invokevirtual   #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   16:  return

编译的代码是相同的。

Answer 2

您可以使用正则表达式来匹配模式。您可以使用stringToMatch.matches(".*?_.*?")。这将返回一个布尔值。

Answer 3

我运行了一些基准测试。这是我能得到的最快的了。

    String a = "Test123";
    String b = "Test123_321tseT_Test_rest";
    int len1 = a.length();
    int len2 = b.length();
    if ((len1 == len2 || (len2 > len1 && (b.charAt(len1)) == '_'))
        && b.startsWith(a)) {
        System.out.println("success");
    } else {
        System.out.println("Fail");
    }

这至少可以在合理的性能下正常工作。

编辑：我切换了_检查和startsWith检查，因为startsWith会使_检查的性能更差。

Edit2：修复了 StringIndexOutOfBoundsException。

Edit3：Peter Lawrey 是正确的，仅对 a.length() 进行 1 次调用可以节省时间。以我为例，为 2.2%。
最新的基准测试显示我比 OP 快 88%，比 Peter Lawrey 的代码快 10%。

Edit4：我用本地变量替换所有 str.length() ，并运行了更多基准测试。现在基准测试的结果变得如此随机，不可能说哪种代码更快。我的最新版本似乎更胜一筹。