黑马程序员技术交流社区

标题: 浅谈字符串的链接删除效率 欢迎讨论 [打印本页]
作者: 紫薰iy    时间: 2014-10-22 12:21
标题: 浅谈字符串的链接删除效率 欢迎讨论
本帖最后由 紫薰iy 于 2014-10-22 12:22 编辑

public class TestStringBuffereBuillder {
        final static int NUM = 100000000;
        public static void main(String[] args) {
                //测试的次数
                for (int j = 0; j < 5; j++) {
                        System.out.print(j+" ");
                        testString();
                        testStringBuffere();
                        testStringBuilder();
                }
               
        }
        public static void testString(){
                String string = "mmmmxxxxyy";
                long startTime = System.currentTimeMillis();
                for (int i = 0; i < NUM; i++) {
                        //String类中的方法，用于在String后连接字符串
                        string.concat("88");
                        //截取新的字符串
                        string = string.substring(0, 10);
                }
                long endTime = System.currentTimeMillis();
                System.out.print((endTime - startTime) + "ms   ");
        }
        public static void testStringBuffere(){
                StringBuffer stringBuffer = new StringBuffer("mmmmxxxxyy");
                long startTime1 = System.currentTimeMillis();
                for (int i = 0; i < NUM; i++) {
                        //StringBuffer与StringBuillder中的方法，末尾添加字符串与删除制定位置的字符串
                        stringBuffer.append("88");
                        stringBuffer = stringBuffer.delete(10, 12);
                }
                long endTime1 = System.currentTimeMillis();
                System.out.print((endTime1 - startTime1) + "ms  ");
        }
        public static void testStringBuilder(){
                StringBuilder stringBuilder = new StringBuilder("mmmmxxxxyy");
                long startTime1 = System.currentTimeMillis();
                for (int i = 0; i < NUM; i++) {
                        stringBuilder.append("88");
                        stringBuilder = stringBuilder.delete(10, 12);
                }
                long endTime1 = System.currentTimeMillis();
                System.out.println((endTime1 - startTime1) + "ms");
        }
}
输出结果


     可以看到，在大量对字符串的操作的情况下，String的效率要低得多。String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。
      而StringBuffere和StringBuilder之间相差的不是太大。使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。

     基本原则：如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffere。

无标题.jpg (21.36 KB, 下载次数: 8)

无标题.jpg
作者: 贾浩田    时间: 2014-10-27 21:00
  1. package itHeima.RUXUE2;

  3. import org.junit.Test;

  5. public class Test16 {
  6.         private final int time = 20000;

  8.         @Test
  9.         public void test(){
  10.                 test_String();
  11.                 test_StringBuffer();
  12.                 test_StringBuilder();
  13.                
  14.         }
  15.        
  16.         //测试String类的增删效率
  17.         public void test_String(){
  18.                 long startTime = myAdvice.getStart();
  19.                 String str = "ABCDE";
  20.                 for(int i = 0; i<time; i++){
  21.                         str = str +"!";
  22.                         str = str.substring(0, i);
  23.                 }
  24.                 long endTime = myAdvice.getEnd();
  25.                 System.out.println("String类的花费时间为："+(endTime-startTime));
  26.         }
  27.         //测试StringBuffer的增删效率
  28.         public void test_StringBuffer(){
  29.                 long startTime = myAdvice.getStart();
  30.                 StringBuffer str = new StringBuffer("ABCDE");
  31.                 for(int i = 0; i<time; i++){
  32.                         str.append("!");
  33.                         str = new StringBuffer(str.substring(0, i));
  34.                 }
  35.                 long endTime = myAdvice.getEnd();
  36.                 System.out.println("StringBuffer类的花费时间为："+(endTime-startTime));
  37.         }
  38.         //测试StringBuilder的增删效率
  39.         public void test_StringBuilder() {
  40.                 long startTime = myAdvice.getStart();
  41.                 StringBuilder str = new StringBuilder("ABCDE");
  42.                 for (int i = 0; i < time; i++) {
  43.                         str.append("!");
  44.                         str = new StringBuilder(str.substring(0, i));
  45.                 }
  46.                 long endTime = myAdvice.getEnd();
  47.                 System.out.println("StringBuilder类的花费时间为：" + (endTime - startTime));
  48.         }
  49.        
  50. }
  51. class myAdvice{
  52.         public static long getStart(){
  53.                 return System.currentTimeMillis();
  54.         }
  55.         public static long getEnd(){
  56.                 return System.currentTimeMillis();
  57.         }
  58. }
复制代码


我也写了一个，不过效果不是很明显，相差的时间并不多，StringBuilder时间用时最少
作者: 紫薰iy    时间: 2014-10-27 23:27
贾浩田 发表于 2014-10-27 21:00
我也写了一个，不过效果不是很明显，相差的时间并不多，StringBuilder时间用时最少 ...

次数太少了。数量少看不到效果



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2