Apache POI Java读取100万行Excel性能优化：split vs indexOf+subString，谁性能好

使用Apache POI eventmodel实现一个Excel流式读取类，目标是100万行，每行46列，文件大小152MB的Excel文件能在20s读取并处理完。一开始实现的程序需要260s，离目标差太远了，使用jvisualvm分析各方法执行时间，结果如下：



可以看到，程序中的splitLine和getRowNum方法消耗了大量时间。这两个方法都特别简单。splitLine方法将类似“123==hello”这样的字符串分解成{"123","hello"}数组，使用了String.split方法，getRowNum从Excel单元格地址字符串（比如“AB123456”）中获取行号“123456”，以下是原始实现方法：

private String getRowNum(String cellRef){
if(cellRef == null || cellRef == ""){
return "-1";
}

String[] nums = cellRef.split("\\D+");
if(nums.length > 1){
return nums[1];
}
return "-1;
}

private String[] splitLine(String line){
return line.split("==");
}

两个如此简单的方法却消耗了这么多时间，一时间不知如何优化。最后突然想到：split的性能是否最优呢？对于如此简单的字符串分割，使用indexOf + subString性能如何呢？于是，我做了如下的实验：

public static void main(String[] args) throws ParseException{
String str = "AB123456";
long start = System.currentTimeMillis();
for(int i = 0 ; i < 10 * 10000 ; i ++){
String[] lines = str.split("\\D+");
}
long end = System.currentTimeMillis();
System.out.println("split time consumed:" + (end - start) / 1000.0 + "s");

start = System.currentTimeMillis();
int index = -1;
for(int i = 0 ; i < 10 * 10000 ; i ++){
index = -1;
for(int k = 0 ; k < str.length() ; k ++){
if(str.charAt(k) >= '0' && str.charAt(k) <= '9'){
index = k;
break;
}
}

if(index > 0){
String[] lines = new String[]{str.substring(0, index),str.substring(index)};
}
}
end = System.currentTimeMillis();
System.out.println("indexof time consumed:" + (end - start) / 1000.0 + "s");
}

以下是输出结果：
split time consumed:0.104s
indexof time consumed:0.007s

虽然表面上看，split比index + subString要简单很多，但后者性能是前者的将近15倍。用这种方法改写前面的splitLine和getRowNum，代码如下：

private String getRowNum(String cellRef){
int index = -1;
for(int k = 0 ; k < cellRef.length() ; k ++){
if(cellRef.charAt(k) >= '0' && cellRef.charAt(k) <= '9'){
index = k;
break;
}
}

if(index >= 0){
String[] nums = new String[]{cellRef.substring(0, index),cellRef.substring(index)};
if(nums.length > 1){
return nums[1];
}
}

return "-1";
}

private String[] splitLine(String line){
int index = line.indexOf("==");

if(index > 0){
return new String[]{line.substring(0, index),line.substring(index + 2)};
}

return new String[0];
}

优化后再用jvisualvm测试各方法执行时间：



可以看到，我自己的数据处理方法已不是明显的性能瓶颈，而Apache POI的zip解压和文件读取占用了绝大部分时间。整体时间也从260s下降到了160s，已有了明显的提高。

我们知道indexOf就是暴力搜索，split内部使用正则表达式做匹配，在搜索字符串较简单时肯定是indexOf性能好。大多数情况下调用split时都用不到正则表达式的那些高大上功能，所以完全没必要图方便在任何时候都用split，而是有所取舍：当简单分割字符串时自己用indexOf实现split，而涉及到复杂的分割操作，不得不用正则表达式时，才用split。为了看清String.split方法在做什么，我们看看JDK中String.split的源码：

public String[] split(String regex, int limit) {
/* fastpath if the regex is a
(1)one-char String and this character is not one of the
RegEx's meta characters ".$|()[{^?*+\\", or
(2)two-char String and the first char is the backslash and
the second is not the ascii digit or ascii letter.
*/
char ch = 0;
if (((regex.value.length == 1 &&
".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
(regex.length() == 2 &&
regex.charAt(0) == '\\' &&
(((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
((ch-'a')|('z'-ch)) < 0 &&
((ch-'A')|('Z'-ch)) < 0)) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else {    // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
// If no match was found, return this
if (off == 0)
return new String[]{this};

// Add remaining segment
if (!limited || list.size() < limit)
list.add(substring(off, value.length));

// Construct result
int resultSize = list.size();
if (limit == 0)
while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
resultSize--;
String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}

尽管split方法的实现还是挺优化的，但仍做了太多的操作。

想一想我过去写的代码经常图方便滥用String.split，这样是经不起大数据量考验的，学了这么长时间Java，竟从没想过这样的问题，不禁感叹自己还是菜鸟。虽然像Java或C#这种语言各种方法使用起来方便，但其库方法之下隐藏的性能开销，需要每一个使用者注意。

（全文完）