JAVA高效处理字符串

以下是测试程序运行结果：

source = a b c d e f g h i j k l m n o p q r s t u v w x y z
字符串中删除字符的方法。
系统函数计算 300000 次用时 1844ms
自定义方法计算 300000 次用时 125ms
生成 abcdefghijklmnopqrstuvwxyz 。
---------- ---------- ---------- ----------

字符串按字符分割的方法。
系统函数计算 300000 次用时 1609ms
自定义方法计算 300000 次用时 281ms
生成 [Ljava.lang.String;@1010058: [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z] 。
---------- ---------- ---------- ----------

能够数倍超越爪哇（Java）类库（Java5.0和Java6.0）中相关方法的性能，究其原因，是因为类库为通用性，提供的相关方法，都采取了正则表达式参数。虽然编译过的正则表达式很高效，但毕竟无法和字符相等这种单拍操作相提并论。

下面把程序发出来，供大家指出错误、讨论以及参考。

首先是删除字符串中某字符的方法。

[java] view plaincopyprint?

1. /** 
2.  * <b>字符串删除其中某字符</b><br/> 
3.  * 本方法用来移除指定字符串中的指定字符。 
4.  * 在 Java 6.0 以内，删除字符串中的指定字符，需要通过 
5.  * {@link String#replace(CharSequence, CharSequence) replace} 方法，将指定单 
6.  * 字符的字符串，替换成空字符串来实现。而 <code>replace</code> 方法为了追求通用， 
7.  * 使用了正则表达式参数。即便是编译过的正则表达式，其性能也无法与简单的字符相等 
8.  * 判断相提并论。<br/> 
9.  * 本方法不涉及正则表达式，通过遍历原字符串对应的字符数组来寻找符合待删除字符的 
10.  * 字符，然后通过 {@link StringBuilder} 来追加其余字符。这是一个简单但高效的方法。 
11.  * <br/> 
12.  * 本方法编写之初，曾试图通过 <code>StringBuilder</code> 的功能来直接删除字符串 
13.  * 中待删除字符。后经 www.iteye.com 网站用户 shenyuc629 提示，并经过考证，发现 
14.  * {@link StringBuilder#deleteCharAt(int) deleteCharAt} 方法并不高效，应该是 
15.  * 因为其内部每次删除都进行了数组迁移。遂改为追加方式，效率提高了 2 倍多。<br/>>> 
16.  * 本方法使用示例如下： 
17.  * <pre> 
18.  * String source = "a b c d e f g h i j k l m n o p q r s t u v w x y z"; 
19.  * String removed = StringTool.removeChar(source, ' ');</pre> 
20.  * 此示例中，{@link String} source 为原字符串。String removed 为删除空格后的 
21.  * 结果。 
22.  * @see     String#replace(CharSequence, CharSequence) 
23.  * @see     StringBuilder#append(char) 
24.  * @param   source  待被处理的字符串，即本方法的“原字符串” 
25.  * @param   target  需要从原字符串中移除的字符 
26.  * @return      从指定原字符串中移除指定字符后所得的结果字符串 
27.  * @exception   NullPointerException    当传入参数 source 为空时 
28.  */  
29. static public String removeChar(String source, char target)  
30. {  
31.     StringBuilder builder = new StringBuilder();  
32.     for (char c: source.toCharArray())  
33.         if (c != target) builder.append(c);  
34.     return builder.toString();  
35. }  

接下来，是字符串分割的方法。

[java] view plaincopyprint?

1. /** 
2.  * <b>简易字符串分割</b><br/> 
3.  * 本方法用来根据指定字符，将某字符串以此为分割，拆分成多个子字符串。 
4.  * 对于分割字符串功能，在 Java 6.0 以内，都只提供了支持正则表达式的 
5.  * {@link String#split(String) split} 方法。此方法为追求通用，即便是简单的 
6.  * 分割，也会基于正则表达式来进行。即便是编译过的正则表达式，其性能也无法与简单 
7.  * 的字符相等判断相提并论。<br/> 
8.  * 本方法不涉及正则表达式，通过遍历原字符串对应的字符数组来寻找符合分割字符的 
9.  * 字符，然后通过 {@link String#substring(int, int)} 来获取每一个分割字符之间 
10.  * 的子字符串，存入一个 {@link LinkedList} 中。这是一个功能简单但高效的方法。 
11.  * 如果规模比较大，拟考虑先通过一次循环，取得原字符串中分割字符的数量，以此制作 
12.  * 定长的 {@link ArrayList} 。 
13.  * 本方法尤其适用于常见的由半角逗号结合在一起的字符串的分割。<br/> 
14.  * 在编写之初，本方法曾采取将字符串的字符数组分段处理，通过系统字符串复制来形成 
15.  * 一个个子字符串。后经考证，{@link String#substring(int, int)} 是一个很高效的 
16.  * 方法，遂改。效率提高了一倍。 
17.  * 本方法使用示例如下： 
18.  * <pre> 
19.  * String source = "a b c d e f g h i j k l m n o p q r s t u v w x y z"; 
20.  * List<String> secs = StringTool.splitSimpleString(source, ' ');</pre> 
21.  * 此示例中，{@link String} source 为原字符串。{@link List} secs 为删除空格后 
22.  * 的结果。 
23.  * @see     String#split(String) 
24.  * @see     String#substring(int, int) 
25.  * @param   source  待被处理的字符串，即本方法的“原字符串” 
26.  * @param   gap     分割字符 
27.  * @return      从指定原字符按分割字符拆分成的子字符串列表 
28.  * @exception   NullPointerException    当传入参数 source 为空时 
29.  */  
30. static public List<String> splitSimpleString(String source, char gap)  
31. {  
32.     List<String> result = new LinkedList<String>();  
33.     char[] sourceChars = source.toCharArray();  
34.     String section = null;  
35.     int startIndex = 0;  
36.     for (int index = -1; ++index != sourceChars.length; )  
37.     {  
38.         if (sourceChars[index] != gap) continue;  
39.         section = source.substring(startIndex, index);  
40.         result.add(section);  
41.         startIndex = index + 1;  
42.     }  
43.     section = source.substring(startIndex, sourceChars.length);  
44.     result.add(section);  
45.     return result;  
46. }  

最后是测试程序。

[java] view plaincopyprint?

1. static public void main(String[] arguments)  
2. {  
3.     // 准备测试内容  
4.     String source = "a b c d e f g h i j k l m n o p q r s t u v w x y z";  
5.     System.out.println("source = " + source);  
6.     int loop = 300000;  
7.     String resultString = null;  
8.     List<String> resultList = null;  
9.     String[] resultArr = null;  
10.     int index = -1;  
11.   
12.     long start = Calendar.getInstance().getTimeInMillis();  
13.     System.out.println("字符串中删除字符的方法。");  
14.   
15.     // 测试 Java 类库提供的字符串删除某字符  
16.     index = -1;  
17.     while (++index != loop)  
18.         resultString = source.replace(" ", "");  
19.     long end1 = Calendar.getInstance().getTimeInMillis();  
20.     System.out.println("系统函数计算 " + loop + " 次用时 " + (end1 - start) + "ms");  
21.   
22.     // 测试自定义的字符串删除某字符  
23.     index = -1;  
24.     while (++index != loop)  
25.         resultString = StringTool.removeChar(source, ' ');  
26.     long end2 = Calendar.getInstance().getTimeInMillis();  
27.     System.out.println("自定义方法计算 " + loop + " 次用时 " + (end2 - end1) + "ms");  
28.   
29.     System.out.println("生成 " + resultString + " 。");  
30.     System.out.println("---------- ---------- ---------- ----------\n");  
31.   
32.     // 测试 Java 类库提供的字符串按某字符分割  
33.     System.out.println("字符串按字符分割的方法。");  
34.     index = -1;  
35.     while (++index != loop) resultArr = source.split(" ");  
36.     long end3 = Calendar.getInstance().getTimeInMillis();  
37.     System.out.println("系统函数计算 " + loop + " 次用时 " + (end3 - end2) + "ms");  
38.   
39.     // 测试自定义的字符串按某字符分割  
40.     index = -1;  
41.     while (++index != loop)  
42.         resultList = StringTool.splitSimpleString(source, ' ');  
43.     long end4 = Calendar.getInstance().getTimeInMillis();  
44.     System.out.println("自定义方法计算 " + loop + " 次用时 " + (end4 - end3) + "ms");  
45.   
46.     System.out.println("生成 " + resultArr + ": " + resultList + " 。");  
47.     System.out.println("---------- ---------- ---------- ----------\n");  
48. }