String 和 StringBuffer 的区别--[Java]

在java中有3个类来负责字符的操作。

1.Character 是进行单个字符操作的。

2.String 对一串字符进行操作。不可变类。

3.StringBuffer 也是对一串字符进行操作，但是可变类。

String:


是对象不是原始类型.

为不可变对象,一旦被创建,就不能修改它的值. <--字符串是字符数组char[int value]，当创建时，value值就不能变了-->

对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.

String 是final类,即不能被继承. <--更能从根本上说明String不可变-->

StringBuffer:


是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象

①：它只能通过构造函数来建立：

StringBuffer sb = new StringBuffer();

②：不能通过付值符号对他进行付值：

sb = "welcome to here!";//error

对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.

向StringBuffer中付值的时候可以通过它的append方法.

sb.append("hello");

字符串连接操作中StringBuffer的效率要比String高:



String str = new String("welcome to ");

str += "here";

的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后再将StringBuffer toSting();
这样的话String的连接操作就比 StringBuffer多出了一些附加操作,当然效率上要打折扣.

并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值.这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

根据上面所说：

情景1：


(1) String result = "hello" + " world";

(2) StringBuffer result = new String().append("hello").append(" world");

(1) 的效率好于 (2)，不要奇怪，这是因为JVM会做如下处理

编译前 String result = "hello" + " world";

编译后 String result = "hello world";

情景2：


(1) public String getString(String s1, String s2) { return s1 + s2; }

(2) public String getString(String s1, String s2) { return new StringBuffer().append(s1).append(s2); }

(1) 的效率与 (2) 一样，这是因为JVM会做如下处理

编译前 return s1 + s2;

编译后 return new StringBuffer().append(s1).append(s2);

情景3：

(1) String s = "s1";

s += "s2";

s += "s3";

(2) StringBuffer s = new StringBuffer().append("s1").append("s2").append("s3");

(2) 的效率好于(1)，因为String是不可变对象，每次"+="操作都会造成构造新的String对象

情景4：

(1) StringBuffer s = new StringBuffer();

for (int i = 0; i < 50000; i ++) {

s.append("hello");

}

(2) StringBuffer s = new StringBuffer(250000);

for (int i = 0; i < 50000; i ++) {

s.append("hello");

}

(2) 的效率好于 (1)，因为StringBuffer内部实现是char数组，默认初始化长度为16，每当字符串长度大于char

数组长度的时候，JVM会构造更大的新数组，并将原先的数组内容复制到新数组，(2)避免了复制数组的开销

从表面看来String类只用一个加号（+）便完成了字符串的拼接，而StringBuffer类却要调用一个append()方法，是否实现起来更简洁，更单纯呢？其实不然，让我们了解一下程序运行内部发生了哪些事情：

经编译后程序的bytecode（字节码）展示出了实质：


在用String类对象直接拼接时，JVM会创建一个临时的StringBuffer类对象，并调用其append()方法完成字符串的拼接，这是因为String类是不可变的，拼接操作不得不使用StringBuffer类（并且－－JVM会将"You are nice."和"I love you so much."创建为两个新的String对象）。之后，再将这个临时StringBuffer对象转型为一个String，代价不菲！可见，在这一个简单的一次拼接过程中，我们让程序创建了四个对象：两个待拼接的String，一个临时StringBuffer，和最后将StringBuffer转型成为的String－－它当然不是最初的str了，这个引用的名称没变，但它指向了新的String对象。

而如果直接使用StringBuffer类，程序将只产生两个对象：最初的StringBuffer和拼接时的String（"I love you so much."），也不再需要创建临时的StringBuffer类对象而后还得将其转换回String对象。

可以想象，当我们的字符串要被循环拼接若干段时，用String类直接操作会带来多少额外的系统开销，生成多少无用的临时StringBuffer对象，并处理多少次无谓的强制类型转换哪

看看以下代码：


将26个英文字母重复加了5000次，

String tempstr = "abcdefghijklmnopqrstuvwxyz";

int times = 5000;

long lstart1 = System.currentTimeMillis();

String str = "";

for (int i = 0; i < times; i++) {

str += tempstr;

}

long lend1 = System.currentTimeMillis();

long time = (lend1 - lstart1);

System.out.println(time);

可惜我的计算机不是超级计算机，得到的结果每次不一定一样一般为 46687左右。

也就是46秒。

我们再看看以下代码

String tempstr = "abcdefghijklmnopqrstuvwxyz";

int times = 5000;

long lstart2 = System.currentTimeMillis();

StringBuffer sb = new StringBuffer();

for (int i = 0; i < times; i++) {

sb.append(tempstr);

}

long lend2 = System.currentTimeMillis();

long time2 = (lend2 - lstart2);

System.out.println(time2);

得到的结果为 16 有时还是 0

所以结论很明显，StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候，差异更大。不信你试试。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jenny0107/archive/2006/08/28/1131381.aspx