Google Guava Splitter 对比 Apache StringUtils

google的guava库是个很不错的工具库,这次来学习其spliiter的用法,它是一个专门用来 
分隔字符串的工具类,其中有四种用法,分别来小结 

1 基本用法 

[html]  view plain  copy

 

1. import com.google.common.base.Splitter;   
2.   
3. public class GuavaSplitterExample {   
4.   
5. public static void main(String[] args) {   
6.   
7. String str = "a,,b,     c,,,d";   
8.   
9. Iterable<String> result = Splitter.on(',')   
10.        .split(str);   
11.   
12. System.out.println("--start--");   
13. for(String s: result){   
14. System.out.println(s);   
15. }   
16. System.out.println("--end--");   
17. }   
18. }   

  输出: 
–start– 
a 

b 
      c 

d 
–end– 


2) 去除空格,使用omitEmptyStrings 

[html]  view plain  copy

 

1. String str = "a,,b,     c,,,d";   
2.   
3. rable<String> result = Splitter.on(',')   
4.     .omitEmptyStrings()   
5.     .split(str);   

输出: 
–start– 
a 
b 
      c 
d 
–end– 

3) 去除每一行的空格 

[html]  view plain  copy

 

1. String str = "a,,b,     c,,,d";   
2.   
3. erable<String> result = Splitter.on(',')   
4.      .trimResults()   
5.      .omitEmptyStrings()   
6.      .split(str);   

输出: 
–start– 
a 
b 
c 
d 
–end– 

4) 还可以指定使用哪些字符去除 

[html]  view plain  copy

 

1. String str = "a,,b,c1,,,d2";   
2.   
3. Iterable<String> result = Splitter.on(',')   
4.        .trimResults(CharMatcher.DIGIT)   
5.        .omitEmptyStrings()   
6.        .split(str);   

输出: 
–start– 
a 
b 
c 
d 

–end– 

 

===================================================

性能对比：

 

首先看基本的使用方法： 

Java代码  

1. // Apache StringUtils...  
2. String[] tokens1= StringUtils.split("one,two,three",',');  
3.    
4. // Google Guava splitter...  
5. Iteratable<String> tokens2 = Splitter.on(','),split("one,two,three");  

很明显，google提供的方法更加的面向对象一点，因为它要先创建一个Splitter对象，然后使用它来分割字符串，而apache的方法则有点函数式编程的味道，它的方法都是静态的。 

这里我更加倾向于采用google的splitter，因为这个对象是可以重用的，且可以在其上附加更多的功能，比如trim，去掉空的元素等，一切都很简单。 

Java代码  

1. Splitter niceCommaSplitter = Splitter.on(',') .omitEmptyString().trimResults();  
2. niceCommaSplitter.split("one,, two,  three"); //"one","two","three"  
3. niceCommaSplitter.split("  four  ,  five  "); //"four","five"  

看起来有点用，还有其他区别么？ 
另外一个需要注意的地方就是Splitter返回的是Iteratable<String>，而StringUtils.split返回的是一个String数组。 

大部分使用分隔符的情况是我们需要对字符串按照分隔符进行遍历处理，仅此而已。 
下面就是常用的代码性能对比的例子： 

Java代码  

1. final String numberList = "One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten";  
2.   
3. long start = System.currentTimeMillis();    
4. for(int i=0; i<1000000; i++) {  
5.     StringUtils.split(numberList , ',');     
6. }  
7. System.out.println(System.currentTimeMillis() - start);  
8.     
9. start = System.currentTimeMillis();  
10. for(int i=0; i<1000000; i++) {  
11.     Splitter.on(',').split(numberList );  
12. }  
13. System.out.println(System.currentTimeMillis() - start);  

代码很简单，就是都对同一个字符串进行100万次的分隔操作，看看时间上的区别，结果如下： 

Java代码  

1. 983  
2. 165  

很明显，guava的速度快很多，这个程序如果运行在每天处理大量字符串的服务中，那么性能差异更加明显。我想其中的原因是Splitter返回的是Iterable<String>，而StringUtils.split返回的是一个String[]，需要创建新的String对象，导致耗时增加。 

如果我们对Splitter对象缓存，那么速度提高更多： 

Java代码  

1. start = System.currentTimeMillis();  
2.     Splitter s = Splitter.on(',');  
3.     for (int i = 0; i < 1000000; i++) {  
4.       s.split(numberList);  
5.     }  
6.     System.out.println(System.currentTimeMillis() - start);  

结果为12，神奇吧，呵呵 

别急，结果还没有出来，目前我们还没有对结果进行处理。我们试试对上面的结果进行处理： 

Java代码  

1. final String numberList = "One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten";  
2.     long start = System.currentTimeMillis();  
3.     for (int i = 0; i < 1000000; i++) {  
4.       final String[] numbers = StringUtils.split(numberList, ',');  
5.       for (String number : numbers) {  
6.         number.length();  
7.       }  
8.     }  
9.     System.out.println(System.currentTimeMillis() - start);  
10.     start = System.currentTimeMillis();  
11.     for (int i = 0; i < 1000000; i++) {  
12.       Iterable<String> is = Splitter.on(',').split(numberList);  
13.       for(String s:is) {  
14.         s.length();  
15.       }  
16.     }  
17.     System.out.println(System.currentTimeMillis() - start);  
18.     start = System.currentTimeMillis();  
19.     Splitter sp = Splitter.on(',');  
20.     for (int i = 0; i < 1000000; i++) {  
21.       Iterable<String> is =  sp.split(numberList);  
22.       for(String s:is) {  
23.         s.length();  
24.       }  
25.     }  
26.     System.out.println(System.currentTimeMillis() - start);  

结果再次令人惊奇： 

Java代码  

1. 851  
2. 2967  
3. 2514  

guava比apache 的StringUtils慢3倍。 

结论： 
很明显，guava把处理时间较长的操作延迟到后面了，前期处理比较快。无论如何，我还是比较倾向于采用guava处理常见的字符串分隔任务，如果你要处理大量分隔后的字符串，且对性能比较关注，那可以使用StringUtils.split。