string str1=”1″+”2″+”3″+….+”1000″;   1式
string str2;
for(int i = 1; i <=1000 ;i++)
str2+=i;                       2式
stringbuffer str3 = new stringbuffer();
for(int i = 1; i <=1000 ;i++)
str3 = str3.append(i);           3式
这三式哪个执行效率高，速度快，为什么？

你怎会想到这问题，围观高人解答

这问题问的好 围观高人解答

1式 最快，这个在编译时就完成了字符串的创建.

2式 最慢，不仅要循环,而且每次都会生成一个StringBuilder对象，连接后再转为String

3式 居中，当添加数据快满的时候,会存在若干次数组的重新分配问题,略费时间。  

按照我个人的经验，第三种效率高些。
第一种：会产生1001个String对象，而且写得很麻烦
第二种：会产生很多的String对象，而且许多都是一次性的对象，浪费内存

3的效率快
1：String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值.
这样原来的对象就没用了,就要被垃圾回收.这是要影响性能的
2:StringBuffer是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象

3最快
1要创建1001个对象

1. /*
   
2. string str1=”1″+”2″+”3″+….+”1000″; 1式
   
3. string str2;
   
4. for(int i = 1; i <=1000 ;i++)
   
5. str2+=i; 2式
   
6. stringbuffer str3 = new stringbuffer();
   
7. for(int i = 1; i <=1000 ;i++)
   
8. str3 = str3.append(i); 3式
   
9. 这三式哪个执行效率高，速度快，为什么？
   
10. 
    
11. 
    
12. 肯定是第三种效率。
    
13. 关于String s ="" ，或String s = new String(""), 其实String变量s 存储的是对String 对象的引用，那么s无论是和常量还是和其他变量相+，
    
14. 在源码里面得到的新串，都是new出来的一个新的String，这个String是放在堆里面的。既然是new 出来的，那自然不是同一个对象.
    
15. 第一种情况 直接用连接符 "+ " 操作，不断的创建新对象来存储前面对象的累加的值，
    
16. 第二种情况 由于使用了for语句，多了判断i<1000 和 i++ 自增的操作，然后继续情况一那种 (个人感觉最慢，运行结果可以看出)。
    
17. 第三种情况 StringBuffer是字符串可变量，可以修改在原有的对象上进行操作，而不创建新对象，
    
18. (由于字符串的长度总是小于或等于生成器的容量StringBuffer.capacity();在计算器内部，字符串生成器是一个数组，如果容量超过实际长度，
    
19. 就会用新的数组来代替原有的数组，新数组大小为2*（前一个数组的大小+1）默认为16空的字符串，所以它所做的就是修改加扩充容量)但是它没有StringBuilder 快
    
20. 原因就是它多了执行同步操作，所以在String 类里 按修改操作的速度从高到低为：StringBuilder>StringBuffer>String
    
21. 
    
22. 
    
23. */
    
24. class String1
    
25. {
    
26. static String str1 = "";
    
27. static int count = 0;
    
28. public static String testString1()
    
29. {
    
30. while(count<=100000)
    
31. {
    
32. str1 = str1 + count++ ;
    
33. }
    
34. 
    
35. return str1;
    
36. }
    
37. 
    
38. public static long getString()
    
39. {
    
40. long startTime = System.currentTimeMillis();
    
41. testString1();
    
42. // System.out.println(testString1());
    
43. long endTime = System.currentTimeMillis();
    
44. long testTime1 = endTime - startTime ;
    
45. return testTime1;
    
46. }
    
47. 
    
48. }
    
49. 
    
50. class String2
    
51. {
    
52. static String str2 = "";
    
53. public static long testString2()
    
54. {
    
55. long startTime = System.currentTimeMillis();
    
56. for(int i = 1; i <=100000 ;i++)
    
57. {
    
58. str2 = str2 + i;
    
59. }
    
60. long endTime = System.currentTimeMillis();
    
61. long testTime2 = endTime - startTime ;
    
62. return testTime2;
    
63. }
    
64. }
    
65. 
    
66. class String3
    
67. {
    
68. 
    
69. public static long testString3()
    
70. {
    
71. StringBuffer str3 = new StringBuffer("");
    
72. long startTime = System.currentTimeMillis();
    
73. for(int i = 1; i <=100000 ;i++)
    
74. {
    
75. str3 = str3.append(i);
    
76. }
    
77. long endTime = System.currentTimeMillis();
    
78. long testTime3 = endTime - startTime ;
    
79. return testTime3;
    
80. }
    
81. }
    
82. 
    
83. class Demo11
    
84. {
    
85. public static void main(String[] args)
    
86. {
    
87. long x,y,z,max;
    
88. x = String1.getString();
    
89. y = String2.testString2();
    
90. z = String3.testString3();
    
91. max = Math.max(Math.max(x,y),z);
    
92. System.out.println("testString1 :" + x +" \ntestString2 :" + y + " \ntestString3 :" + z +" \n耗时最多的是 : " +((max==x)?"String1":((max==y)?"String2":"String3")));
    
93. }
    
94. }
    
95. 
    
96. /*
    
97. 
    
98. 1.当运行 1000次的时候 第一种情况和第二种时间差不多
    
99. <IMG border=0 alt="" src="http://bbs.itheima.com/forum.php?mod=image&aid=10993&size=300x300&key=88cebce453658eeaf5051664c31245bd&nocache=yes&type=fixnone" aid="attachimg_10993">
    
100. 2.当运行 100,000次的时候 第一种情况比第二种情况多了一百多点时间，除去一万次的count累加和while(count<=100,000)次判断，
     
101. 第一种应该比第二中情况效率.
     
102. <IMG border=0 alt="" src="http://bbs.itheima.com/forum.php?mod=image&aid=10992&size=300x300&key=1a5ab0d6b269bca0e33cbf02c9102ff0&nocache=yes&type=fixnone" aid="attachimg_10992">
     
103. */

复制代码

楼主关于你的这个问题：对于字符串的遍历，
第一种方式：
  or(int i = 1; i <=1000 ;i++)
str2+=i;                     
这是通过数组来遍历的。查询快，但是增删慢。
第二种：
  tringbuffer str3 = new stringbuffer();
for(int i = 1; i <=1000 ;i++)
str3 = str3.append(i);           3式
  通过StringBuffer来的。StringBuffer是线程安全的，因为使用了同步的原因，所以使用的对数据操作的话
效率不高。
所以对比你就可以知道：使用的是第二种方式数组遍历的话速度快。不过你说的第一种方式什么？我看了大半天。都没看出来在哪里！

很负责的告诉LZ 肯定是第一种方式效率最高的，因为他在编译的时候就已经计算出了，根本不用运行的时候去计算。
至于其他两种方式大家都知道区别我就不多说了  
对于第一种方式你哪怕是加到100000基本你在运行的时候都是0-2，你会看见基本就没在运行上面耗费时间。
你可以自己写代码试试 如果觉得写到1000很麻烦 给你方儿  你写到20的时候  就直接复制复制10行 再以10行复制 100行复制 1000行复制 很快就100000了
这个时候你保存  你会发现你的电脑就很卡了 其实这个时候就在计算了

周超 发表于 2012-12-24 22:04

同学 貌似你第一种方式大部分时间都用在了循环去了
其实第一种应该是最快的

应该是第三个效率最快！

张森 发表于 2013-1-2 04:29
很负责的告诉LZ 肯定是第一种方式效率最高的，因为他在编译的时候就已经计算出了，根本不用运行的时候去计 ...

大哥！！第一种方式在创建时需建立1001个对象，且没有垃圾回收！你居然说第一种效率最高？？


至于第三种效率最高的朋友！你们是否考虑了StringBuffer的同步属性呢？StringBuider在这里使用会否更好！由于是遍历嘛！但是StringBuffer有一个自动增加数组长度动作，每次快慢了就加一点！感觉好像没第二种快！其实差别应该不大把！

string str1=”1″+”2″+”3″+….+”1000″;   1式
string str2;
for(int i = 1; i <=1000 ;i++)
str2+=i;                       2式
stringbuffer str3 = new stringbuffer();
for(int i = 1; i <=1000 ;i++)
str3 = str3.append(i);           3式
第三个效率高，速度快些，因为第三个每次调用方法不需要创建新的对象，第一种每次改变都要创建新的String对象，第一个更慢，因为没循环一次之后还需要创建新的String对象

你好
第一种效率最快，字符串常量在编译时期已经被确定，不会创建新的字符串。
第二种最慢，遍历的同时产生了很多字符串对象。
第三种居中，将字符串常量添加到可变字符串中。