更快的实现：利用 String.regionMatches()
使用正则表达式可能相对较慢。如果只想检查一种情况，它（变慢）无关紧要。但是，如果您有一个数组或成千上万个字符串的集合，事情可能会变得很慢。
下面提供的解决方案既不使用正则表达式，也不行toLowerCase()（这很慢，因为它会创建另一个字符串，并在检查后将它们扔掉）。
该解决方案基于String.regionMatches（）似乎未知方法。它检查2个String区域是否匹配，但是重要的是它还有一个带有方便ignoreCase参数的重载。
public static boolean containsIgnoreCase(String src, String what) {
final int length = what.length();
if (length == 0)
return true; // Empty string is contained
final char firstLo = Character.toLowerCase(what.charAt(0));
final char firstUp = Character.toUpperCase(what.charAt(0));
for (int i = src.length() - length; i >= 0; i--) {
// Quick check before calling the more expensive regionMatches() method:
final char ch = src.charAt(i);
if (ch != firstLo && ch != firstUp)
continue;
if (src.regionMatches(true, i, what, 0, length))
return true;
}
return false;
}
速度分析
这种速度分析并不意味着要成为火箭科学，只是粗略了解不同方法的速度。
我比较5种方法。
- 我们的 containsIgnoreCase（）方法。
- 通过将两个字符串都转换为小写并调用
String.contains()。
- 通过将源字符串转换为小写并
String.contains()使用预先缓存的小写子字符串进行调用。该解决方案已经不够灵活，因为它会测试predefiend子字符串。
- 使用正则表达式（可接受的答案
Pattern.compile().matcher().find()...）
- 使用正则表达式，但具有预先创建和缓存的内容
Pattern。该解决方案已经不够灵活，因为它会测试预定义的子字符串。
结果（通过调用该方法一千万次）：
- 我们的方法：670毫秒
- 2x toLowerCase（）和contains（）：2829毫秒
- 1个toLowerCase（）和contains（）带有缓存的子字符串：2446 ms
- 正则表达式：7180毫秒
- 正则表达式缓存
Pattern：1845毫秒
表中的结果：
RELATIVE SPEED 1/RELATIVE SPEED
METHOD EXEC TIME TO SLOWEST TO FASTEST (#1)
------------------------------------------------------------------------------
1. Using regionMatches() 670 ms 10.7x 1.0x
2. 2x lowercase+contains 2829 ms 2.5x 4.2x
3. 1x lowercase+contains cache 2446 ms 2.9x 3.7x
4. Regexp 7180 ms 1.0x 10.7x
5. Regexp+cached pattern 1845 ms 3.9x 2.8x
我们的方法是快4倍相比lowercasing和使用contains()，速度快10倍相比，使用正则表达式，也快3倍，即使Pattern是预先缓存（大和丢失的任意子检查的灵活性）。
分析测试代码
如果您对分析的执行方式感兴趣，请参见完整的可运行应用程序：
import java.util.regex.Pattern;
public class ContainsAnalysis {
// Case 1 utilizing String.regionMatches()
public static boolean containsIgnoreCase(String src, String what) {
final int length = what.length();
if (length == 0)
return true; // Empty string is contained
final char firstLo = Character.toLowerCase(what.charAt(0));
final char firstUp = Character.toUpperCase(what.charAt(0));
for (int i = src.length() - length; i >= 0; i--) {
// Quick check before calling the more expensive regionMatches()
// method:
final char ch = src.charAt(i);
if (ch != firstLo && ch != firstUp)
continue;
if (src.regionMatches(true, i, what, 0, length))
return true;
}
return false;
}
// Case 2 with 2x toLowerCase() and contains()
public static boolean containsConverting(String src, String what) {
return src.toLowerCase().contains(what.toLowerCase());
}
// The cached substring for case 3
private static final String S = "i am".toLowerCase();
// Case 3 with pre-cached substring and 1x toLowerCase() and contains()
public static boolean containsConverting(String src) {
return src.toLowerCase().contains(S);
}
// Case 4 with regexp
public static boolean containsIgnoreCaseRegexp(String src, String what) {
return Pattern.compile(Pattern.quote(what), Pattern.CASE_INSENSITIVE)
.matcher(src).find();
}
// The cached pattern for case 5
private static final Pattern P = Pattern.compile(
Pattern.quote("i am"), Pattern.CASE_INSENSITIVE);
// Case 5 with pre-cached Pattern
public static boolean containsIgnoreCaseRegexp(String src) {
return P.matcher(src).find();
}
// Main method: perfroms speed analysis on different contains methods
// (case ignored)
public static void main(String[] args) throws Exception {
final String src = "Hi, I am Adam";
final String what = "i am";
long start, end;
final int N = 10_000_000;
start = System.nanoTime();
for (int i = 0; i < N; i++)
containsIgnoreCase(src, what);
end = System.nanoTime();
System.out.println("Case 1 took " + ((end - start) / 1000000) + "ms");
start = System.nanoTime();
for (int i = 0; i < N; i++)
containsConverting(src, what);
end = System.nanoTime();
System.out.println("Case 2 took " + ((end - start) / 1000000) + "ms");
start = System.nanoTime();
for (int i = 0; i < N; i++)
containsConverting(src);
end = System.nanoTime();
System.out.println("Case 3 took " + ((end - start) / 1000000) + "ms");
start = System.nanoTime();
for (int i = 0; i < N; i++)
containsIgnoreCaseRegexp(src, what);
end = System.nanoTime();
System.out.println("Case 4 took " + ((end - start) / 1000000) + "ms");
start = System.nanoTime();
for (int i = 0; i < N; i++)
containsIgnoreCaseRegexp(src);
end = System.nanoTime();
System.out.println("Case 5 took " + ((end - start) / 1000000) + "ms");
}
}