Java最佳实践–字符串性能和精确字符串匹配

在使用Java编程语言时，我们将继续讨论与建议的实践有关的系列文章，我们将讨论String性能调优。我们将专注于如何有效地处理字符串创建，字符串更改和字符串匹配操作。此外，我们将提供我们自己的用于精确字符串匹配的最常用算法的实现。与Java开发工具包中提供的用于精确字符串匹配的幼稚方法相比，这些算法中的许多算法都可以实现更好的性能。本文以上述精确字符串匹配算法之间的性能比较作为结束。

所有讨论的主题均基于用例，这些用例来自于电信行业的关键任务超高性能生产系统的开发。

在阅读本文的每个部分之前，强烈建议您参考相关的Java API文档以获取详细信息和代码示例。

所有测试均针对具有以下特征的Sony Vaio进行：

系统：openSUSE 11.1（x86_64）
处理器（CPU）：Intel（R）Core（TM）2 Duo CPU T6670 @ 2.20GHz
处理器速度：1,200.00 MHz
总内存（RAM）：2.8 GB
Java：OpenJDK 1.6.0_0 64位

应用以下测试配置：

并发工作者线程数：1
每个工作人员重复测试的次数：1000
整体测试次数：100

字符串性能调优

许多人在使用String对象时并没有考虑性能。但是，滥用String类可能会严重降低应用程序的性能。您应该记住的最重要的事情是：

字符串对象是不可变的。一旦创建了String对象，就无法更改它。每个更改String的操作都会导致至少创建一个新的对象实例。例如，使用串联运算符（+）串联两个字符串会导致创建两个新对象，一个用于实际串联的临时StringBuffer对象，一个指向串联结果的新String实例（ StringBuffer “ toString（）”操作为用于实例化生成的String ）。另一方面，与串联运算符（+）相比，使用String “ concat（String ..）”操作执行String串联将提供更好的性能结果。在后台，字符串 “ concat（String ..）”操作利用本机“ System.arrayCopy”操作来准备一个带有两个串联字符串内容的字符数组。最后，创建一个新的String实例，该实例指向连接的结果
字符串引用是指向实际String对象实例的指针。因此，如果实际的String对象不同，则使用“ ==”运算符比较表示相同文字内容的两个String实例将返回“ false”。此外，使用String “ equals（String ..）”或String “ equalsIgnoreCase（String ..）”操作比较两个String实例可提供有效的结果，但如果两个比较的String分别由不同的实例表示，则执行字符与字符的比较。它们的文字内容具有相同的长度。可以想象，“ equals（String ..）”和“ equalsIgnoreCase（String ..）”操作比“ ==”运算符要昂贵得多，后者在实例级别比较字符串。然而，上述操作在所有文字内容检查之前执行实例相等性检查（ this == obj ）。为了能够在比较String实例时受益于“ this == obj”的相等性检查，应将String值定义为文字字符串和/或字符串值常量表达式。这样做，您的String实例将被JVM自动插入。另一种但不受欢迎的方法是使用字符串 “ intern（）”操作，以便手动插入字符串。正如Java文档中针对“ intern（）”方法明确指出的那样，

“最初为空的字符串池由String类私下维护。
调用intern方法时，如果池已经包含等于equals（Object）方法确定的此String对象的字符串，则返回池中的字符串。

否则，将此String对象添加到池中，并返回对此String对象的引用。

因此，对于任何两个字符串s和t，当且仅当s.equals（t）为true时，s.intern（）== t.intern（）为true。

所有文字字符串和字符串值常量表达式都将被嵌入。”

我们建议在处理String类时的最佳做法如下：

赞成创建文字字符串和字符串值常量表达式，而不是使用String构造函数方法之一创建新的String对象
利用字符数组执行String转换操作可获得最佳性能结果，但灵活性较差
在执行String转换操作（例如，删除，插入，替换或附加字符，连接或拆分String）时，请使用StringBuilder或StringBuffer类。 StringBuilder类在Java 1.5中引入，并且是StringBuffer类的非同步对等形式。因此，如果只有一个线程将执行String转换操作，则倾向于使用StringBuilder类，因为它是性能最好的

模式优先精确字符串匹配

Java语言缺少快速的字符串搜索算法。字符串 “ indexOf（…）”和“ lastIndexOf（…）”操作针对源文本对所提供的模式执行幼稚搜索。天真的搜索基于“强力”模式第一个精确的字符串匹配算法。 “强力”算法包括检查文本中所有位置的模式是否从那里开始。然后，每次尝试后，它都会将图案恰好向右移动一个位置。但是，仍然存在其他几种算法，它们在速度和效率上都远胜过“蛮力”算法。

应用程序需要两种解决方案，具体取决于首先给出哪个字符串，模式或文本。在我们的例子中，模式是预先提供的，这意味着我们总是针对未知文本搜索提供的模式。对于需要全文搜索（文本优先精确字符串匹配）的所有应用程序，需要一套不同的算法来提供索引扫描。 Apache Lucene是实现后一种算法家族的最受欢迎的文本搜索引擎库之一。尽管如此，本文只会研究第一种算法。

感谢这项伟大的工作，来自鲁昂大学信息学院的鲁昂大学的Christian Charras和Thierry Lecroq的一本书名为“ 精确字符串匹配算法 ”，我们得以用Java实现最精确的字符串匹配算法。，先给出模式。下面的列表显示Christian Charras和Thierry Lecroq所提供的算法名称，并在括号中显示我们的算法实现“代码名称”。有关每种算法的更多信息，请单击相应的链接，以便重定向到“精确字符串匹配算法”一书的相关部分。

蛮力算法（BF）
确定性有限自动机算法（DFA）
Karp-Rabin算法（KR）
移位或算法（SO）
Morris-Pratt算法（MP）
Knuth-Morris-Pratt算法（KMP）
西蒙算法（SMN）
Colussi算法（CLS）
Galil-Giancarlo算法（GG）
Apostolico-Crochemore算法（AC）
不太天真算法（NSN）
Boyer-Moore算法（BM）
Turbo BM算法（TBM）
Apostolico-Giancarlo算法（AG）
反向Colussi算法（RC）
Horspool算法（HP）
快速搜索算法（QS）
调优的Boyer-Moore算法（BMT）
Zhu-Takaoka算法（ZT）
Berry-Ravindran算法（BR）
史密斯算法（SMT）
Raita算法（RT）
逆因子算法（RF）
Turbo逆因子算法（TRF）
前向Dawg匹配算法（FDM）
后向不确定Dawg匹配算法（BNDM）
向后Oracle匹配算法（BOM）
Galil-Seiferas算法（GS）
双向算法（TW）
有序字母算法中的字符串匹配（SMOA）
最佳失配算法（OM）
最大移位算法（MS）
跳过搜索算法（SS）
KMP跳过搜索算法（KPMSS）

在“精确字符串搜索算法”套件的初始版本（1.0.0）中，对于每种算法，我们都实现了三个实用程序操作：

compile（String pattern）–基于提供的模式执行所有必要预处理的静态操作
findAll（String source）–返回包含所有索引的列表，其中搜索算法指示有效的模式匹配
findAll（String pattern，String source）–这是一个辅助静态操作，封装了上述两个操作的功能

下面是使用Boyer-Moore算法（BM）的示例：

情况1

 BM bm = BM.compile(pattern);  List<Integer> idx = bm.findAll(source);  List<Integer> idx2 = bm.findAll(source2);  List<Integer> idx3 = bm.findAll(source3);

情况＃2

 List<Integer> idx = BM.findAll(pattern, source);

在第一种情况下，我们编译模式并以两个不同的步骤执行搜索。当我们必须在多个源文本中搜索同一模式时，此方法是合适的。通过编译模式，由于预处理通常是繁重的操作，因此我们可以最大化性能结果。另一方面，对于一次搜索，第二种方法提供了更方便的API。

我们必须指出我们提供的实现是线程安全的，并且当前我们不支持模式中的正则表达式。

以下是我们的精确字符串搜索算法套件的算法实现之间的示例性能比较。我们使用65535个字符的完整字母大小搜索了1150000个字符的文本，以查找故意不存在的37个字符的短语。请不要忘记这是一个相对的性能比较。绝大多数提供的搜索算法的性能结果在很大程度上取决于提供的文本，提供的模式和字母大小。因此，您应该只将String搜索算法之间的所有性能比较视为相对的。

在本节的开头，我们已经声明Java语言缺少快速的String搜索算法。但是，与我们的算法套件相比，标准的Java天真的实现有多慢？为了回答上述问题，我们实现了两种方法，以便使用标准Java API检索潜在模式匹配的所有索引值：

方法1 – indexOf（）方法

 public static List<Integer> findAll(String pattern, String source) { List<Integer> idx = new ArrayList&ltInteger>(); int id = - 1 ; int shift = pattern.length(); int scnIdx = -shift; while (scnIdx != - 1 || id == - 1 ) { idx.add(scnIdx); id = scnIdx + shift; scnIdx = source.indexOf(pattern, id); } idx.remove( 0 ); return idx; }

方法2 – Matcher find（）方法

 public static List<Integer> findAll(String pattern, String source) { List<Integer> idx = new ArrayList&ltInteger>(); Pattern ptrn = Pattern.compile(pattern); Matcher mtch = ptrn.matcher(source); while (mtch.find()) idx.add(mtch.start());   return idx; }

下面我们给出上述搜索算法之间的性能比较表

水平轴表示每种算法进行预处理和解析提供的文本所需的平均时间（以毫秒为单位）。因此，较低的值更好。如您所见，Java天真实现（indexOf（）方法）以及几乎所有我们的搜索算法实现都优于Java Matcher“ find（）”方法。换句话说，当您处理中小型字符串搜索时，最好实现类似于我们上面提供的代码片段之类的东西，而不要使用更复杂的字符串搜索算法。另一方面，处理大型文档时，我们套件中最快的算法之一肯定会派上用场！

您可以在此处下载精确字符串搜索算法套件发行版的1.0.0版

快乐编码

贾斯汀

相关文章：