Java 中的高效字符串查找193

在 Java 编程中，字符串查找是一项常见的操作，用于定位文本中的特定字符或字符串。Java 提供了多种方法来执行字符串查找，每种方法都有其独特的优点和缺点。

indexOf() 和 lastIndexOf() 方法

indexOf() 和 lastIndexOf() 方法可用于查找字符串中字符或子字符串的第一个或最后一个匹配项。这两个方法都返回匹配项在字符串中的索引，如果未找到匹配项，则返回 -1。```java
String text = "Hello World";
int index = ("o"); // 返回 4
int lastIndex = ("o"); // 返回 7
```

contains() 方法

contains() 方法可用于检查字符串中是否存在指定的字符或子字符串。该方法返回一个布尔值，表示是否存在匹配项。```java
String text = "Hello World";
boolean hasWorld = ("World"); // 返回 true
```

matches() 方法

matches() 方法可用于检查字符串是否与指定的正则表达式匹配。正则表达式是一种模式匹配语法，可用于查找复杂模式。```java
String text = "12345";
boolean isNumeric = ("^[0-9]+$"); // 返回 true
```

Pattern 和 Matcher 类

Pattern 和 Matcher 类提供了更高级别的字符串查找功能。Pattern 类表示要匹配的正则表达式，而 Matcher 类用于执行实际匹配操作。```java
Pattern pattern = ("ab*");
Matcher matcher = ("abaabb");
while (()) {
(()); // 输出 "ab"、"aa"、"abb"
}
```

Knuth-Morris-Pratt (KMP) 算法

KMP 算法是一种高效的字符串匹配算法，用于在给定文本中查找模式。与朴素算法相比，它在查找过程中的平均比较次数更少。```java
public class KMP {
public static int[] computePrefixFunction(String pattern) {
int[] prefix = new int[()];
int i = 1;
int j = 0;
while (i < ()) {
if ((i) == (j)) {
prefix[i] = j + 1;
i++;
j++;
} else if (j == 0) {
prefix[i] = 0;
i++;
} else {
j = prefix[j - 1];
}
}
return prefix;
}
public static int KMP(String text, String pattern) {
int[] prefix = computePrefixFunction(pattern);
int i = 0;
int j = 0;
while (i < ()) {
if ((i) == (j)) {
i++;
j++;
} else if (j == 0) {
i++;
} else {
j = prefix[j - 1];
}
if (j == ()) {
return i - ();
}
}
return -1;
}
}
```

Rabin-Karp 算法

Rabin-Karp 算法是一种哈希函数驱动的字符串匹配算法。它将字符串和模式转换为数字，并使用哈希函数来比较它们。如果哈希值匹配，则执行更详细的比较来确认匹配。```java
public class RabinKarp {
public static int RabinKarp(String text, String pattern) {
int prime = 31;
int patternHash = 0;
int textHash = 0;
for (int i = 0; i < (); i++) {
patternHash = (patternHash * prime + (i)) % Integer.MAX_VALUE;
textHash = (textHash * prime + (i)) % Integer.MAX_VALUE;
}
for (int i = 0; i = 0; i--) {
int j = i;
int k = () - 1;
while (j >= 0 && (j) == (k)) {
j--;
k--;
}
if (j == -1) {
goodSuffix[i] = () - 1 - i;
} else {
goodSuffix[i] = () - 1 - k;
}
}
for (int i = 0; i < () - 1; i++) {
int j = i;
int k = () - 1;
while (j >= 0 && (j) == (k)) {
j--;
k--;
}
if (j == -1 && goodSuffix[i] == i + 1) {
for (int l = i + 1; l < () - 1; l++) {
goodSuffix[l] = goodSuffix[i];
}
}
}
return goodSuffix;
}
}
```