一道面试题,关于代码的性能的问题.

Question

下面的代码存在性能的问题,请指出,并改正:
public static int testroop(int rooptime){  String str = new String("testString");  for(int i = 0;i < rooptime;i ++){
    char ch = 'a';
    str += ch;
  }  return rooptime;
}

Answer 1

我看到 String str = new String("testString");有问题,不知道还有没有其他.

Answer 2

char ch = 'a';//应该放在外面定义比较好一点
    str += ch;//要用str构造成StringBuffer类的，否则每次用＋操作时都会系统生成一个StringBuffer实例，效率当然不行。看一下String类的源代码就行了。
public static int testroop(int rooptime){
  String str = new String("testString");
  StringBuffer sb = new StringBuffer(str);
  char ch= 'a';
  for(int i = 0;i < rooptime;i ++){
    
    sb.append(ch);
  }  return rooptime;
}

Answer 3

public static int testroop(int rooptime){  String str = new String("testString");  for(int i = 0;i < rooptime;i ++){
    char ch = 'a';
    str += ch;
  }  return rooptime;
}
1．String类对象为常量对象，创建后值不可变，所以每次循环都是ＳＴＲ从新指向一个新的ＳＴＲＩＮＧ类对象先前的哪个边垃圾，浪费内存

Answer 4

问题都出在String上面String是不可变对象所以
String str = new String("testString")这样其实创建了两个对象;改为String str = "testString";
  循环里面应该用StringBffer
char ch = 'a';
StringBuffer bf= new StringBffer("");  
for(int i = 0;i < rooptime;i ++){
    bf.append(++ch);
  }
return bt.toString();

Answer 5

1要判定传近来的数值大于0
2根据 rooptime分配内存
3循环对内存赋值而不是append

Answer 6

平凡的字符串累加因改用StringBuffer,而不是String
public static int testroop(int rooptime){
StringBuffer str = new StringBuffer("testString");
for(int i = 0;i < rooptime;i ++){
char ch = 'a';
str.append(ch);
}
return rooptime;
}

Answer 7

关于String和StringBuffer大家都说了.我来说说for如果真的这么在乎性能. 那for也应该要改改啦.如下:for(int i=rooptime;i>0;i--)

Answer 8

for(int i=rooptime;i>0;i--)
为什么要这样改?

Answer 9

比如rooptime为1000, i为0-1000中任一数. 在机器执行起来的时候,i和0和比较要比i和1000的比较的速度快.很久以前在J2ME的书上看到过这个说法. 好像是一个叫做什么森的书.好像很有名的.

Answer 10

学习了
String str = new String("testString");  for(int i = 0;i < rooptime;i ++){
    char ch = 'a';
    str += ch;
  }
这段代码有什么用？外界又用不到str变量

Answer 11

String str = new String("testString");
  char[] buffer = new char[str.length+rooptime];
  System.arraycopy(buffer,0,str.toCharArray(),0,str.length());
  Arrays.fill(buffer,str.length(),buffer.length,'a');
  这样比用StringBuffer更有效

Answer 12

呵呵 我觉得分数应该给 zisidemao(zisidemao) 同志一大半str += ch;
问题出在这个地方了
String是不能改变的 这样写的话会不停的产生新的对象

Answer 13

public static int testroop(int rooptime){/*  String str = new String("testString");  for(int i = 0;i < rooptime;i ++){
    char ch = 'a';
    str += ch;
  }
*/都没用
  return rooptime;
}

Answer 14

String str = new String("testString");
这一句也应该改成
String str = "testString";

Answer 15

个人觉得for不用去改了，做题要猜想出题人到底想考一下什么？
我觉得这道题主要就是考String和StringBuffer的区别，这是初级面试题里面常考的一个问题，如果大家用DeBug进行跟踪就会发现String完成的"+"法其实做了很多事。而且String是基于“不变模式”的，也就是说每一次"+"后的结果其实是申请了一次内存资源，并将原有的资源回收，这里才是性能问题出现的地方

Answer 16

这道题的性能问题就是垃圾代码！（为什么猜想出题人到底想考一下什么？又不是上学考试）
改为这个：
public static int testroop(int rooptime){
  return rooptime;
}

Answer 17

我真的不知道这个代码有什么讨论的价值，仔细看看这个代码
public static int testroop(int rooptime){/*  String str = new String("testString");  for(int i = 0;i < rooptime;i ++){
    char ch = 'a';
    str += ch;
  }
*/都没用
  return rooptime;
}
这个函数到底有什么垃圾用,传个参数进来再返回去，参数也没有发生什么变化，晕,方法都没有任何功能，讨论性能有何意义

Answer 18

不要讨论这段代码有什么用，问题都说的很清楚了，让你找出代码的性能问题我认为是char ch = 'a'; 这句话的问题变量的声明不能放在循环中！！！

Answer 19

to chuan122345() :
赞一个! 我认同你的观点! 偶开始也被迷惑啦.faint~~

Answer 20

用StringBuffer类，当你的程序频繁要组装数组时。

Answer 21

由于代码中存在很多的String + 运算，所以用StringBuffer代替String，可以明细改善性能，特别当rooptime很大的时候
public static int testroop(int rooptime){  StringBuffer str = new StringBuffer("testString");  for(int i = 0;i < rooptime;i ++){
    char ch = 'a';
    str.append(ch);
  }  return rooptime;
}

Answer 22

UP一下:
public static int testroop(int rooptime){
  String str = new String("testString");
  StringBuffer sb = new StringBuffer(str);
  char ch= 'a';
  for(int i = 0;i < rooptime;i ++){
    
    sb.append(ch);
  }  return rooptime;
}

Answer 23

public static int testroop(int rooptime){
  StringBuffer sb = new StringBuffer("testString");
  char ch= 'a';
  for(int i = 0;i < rooptime;i ++){
    
    sb.append(ch);
  }  return rooptime;
}

Answer 24

public static int testroop(int rooptime){
  StringBuilder sb = new StringBuilder("testString");
  char ch= 'a';
  for(int i = 0;i < rooptime;i ++){
    
    sb.append(ch);
  }  return rooptime;
}//stringBuilder 比stringbuffer 还好用.呵呵

Answer 25

性能吗？rooptime要一直开方到2，不要循环那么多次

Answer 26

这道题我在华为面试时做过
问题都出在String上面String是不可变对象所以
String str = new String("testString")这样其实创建了两个对象;改为String str = "testString";
  循环里面应该用StringBffer
char ch = 'a';
StringBuffer bf= new StringBffer("");  
for(int i = 0;i < rooptime;i ++){
    bf.append(++ch);
  }
return bt.toString();

Answer 27

楼上正解，用StringBuffer性能更好.

Answer 28

//第一：这段代码没有任何意义。出题的人很垃圾，倒不如问些实际的，string 与stringbuffer有什么差异之类的。
//第二：如果非要在这里面寻找性能的话问题的话。stringBuffer也不是最好的。
import java.util.*;
class testIt 
{
 public static int testroop(int rooptime){
  String str = new String("testString");
  char[] acTmp1  = str.toCharArray();
  int iPos = acTmp1.length;
  char[] acTmp2 = new char[iPos+rooptime];
  System.arraycopy(acTmp1,0,acTmp2,0,iPos);   char ch = 'a';
  for(;iPos < rooptime;iPos ++){    
acTmp2[iPos] = ch;
  }
  str = new String(acTmp2);   return rooptime;
    } //随便拷贝一段函数
public static int testroop2(int rooptime){   StringBuffer str = new StringBuffer("testString");
  char ch = 'a';
  for(int i = 0;i < rooptime;i ++){    
str.append(ch);
  }
  return rooptime;
} public static void main(String[] args) 
{

Date dt1 = new Date();
testroop(10000000);
Date dt2 = new Date();
System.out.println("cost1 =["+(dt2.getTime() - dt1.getTime())+"]"); Date dt3 = new Date();
testroop2(10000000);
Date dt4 = new Date();
System.out.println("cost2 =["+(dt4.getTime() - dt3.getTime())+"]");
}
}
// 两段同时编译的代码运行的时间比是 cost1:cost2 == 2:5  200:500
// 注释掉其中一段分别运行 cost1 =180   cost2 = 900

Answer 29

其实找一下string 和stringbuffer的源代码看一下知道了。