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

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）中相关方法的性能，究其原因，是因为类库为通用性，提供的相关方法，都采取了正则表达式参数。虽然编译过的正则表达式很高效，但毕竟无法和字符相等这种单拍操作相提并论。

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

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

 
  
  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. } 
 
  

 接下来，是字符串分割的方法。
 
  
 
  
  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. } 
 
  
 
 
  
最后是测试程序。
  
 
  
 
  
  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. } 
 
  
 
 
  
本文也在我 CSDN 的博客发表： http://blog.csdn.net/shanelooli/article/details/8123094
 也在 ITeye 发表： http://surmounting.iteye.com/blog/1707259
 也在中国开源社区发表： http://my.oschina.net/shane1984/blog/85861