整理下java中stringBuilder和stringBuffer两个类的区别

StringBuilder和StringBuffer这两个类在动态拼接字符串时经常使用，确定比String的效率和开销小，这是由于String的对象不会回收哦。

其实我一直用StringBuilder这个类，由于能够简写为sb的变量在程序里很爽，但是后来师兄说web程序特别是高并发的程序中不要用stringbuilder，由于简单说，stringBuilder不是线程安全的，而StirngBuffer就是线程安全的。从网上看到Stringbuffer中方法大都采用了synchronized的关键字修饰。

来来来，咱们先复习下syncronized的用法，有篇博客写的挺好的，给个连接 http://leo-faith.iteye.com/blog/177779

一、synchronized关键字的做用域有二种： 1）是某个对象实例内，synchronized aMethod(){}能够防止多个线程同时访问这个对象的synchronized方法（若是一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不一样的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样能够同时访问相同类的另外一个对象实例中的synchronized方法； 2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它能够对类的全部对象实例起做用。

 

二、除了方法前用synchronized关键字，synchronized关键字还能够用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的做用域是当前对象；

三、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类须要你显式的指定它的某个方法为synchronized方法；

好了，言归正传，咱们继续StringBuffer和StringBuilder的区别。

就是说，StringBuffer中全部的方法都要加锁，因此好多操做看上去都是线性操做的。因此要慢些。

通常状况下,速度从快到慢:StringBuilder>StringBuffer>String.当须要在循环中屡次使用字符串拼接时,建议使用StringBuilder或StringBuffer.当数量级在百万级(这里可能不许确)时,StringBuilder的速度会体现出来.

如下是实验数据

final static int ttime = 30000;// 测试循环次数

	public void test(String s) {
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ttime; i++) {
			s += "add";
		}
		long over = System.currentTimeMillis();
		System.out.println(" 操做 " + s.getClass().getName() + " 类型使用的时间为： " + (over - begin) + " 毫秒 ");
	}

	public void test(StringBuffer s) {
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ttime; i++) {
			s.append("add");
		}
		long over = System.currentTimeMillis();
		System.out.println(" 操做 " + s.getClass().getName() + " 类型使用的时间为： " + (over - begin) + " 毫秒 ");
	}

	public void test(StringBuilder s) {
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ttime; i++) {
			s.append("add");
		}
		long over = System.currentTimeMillis();
		System.out.println(" 操做 " + s.getClass().getName() + " 类型使用的时间为： " + (over - begin) + " 毫秒 ");
	}

	// 对 String 直接进行字符串拼接的测试
	public void test2() {
		String s2 = "abadf";
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ttime; i++) {
			String s = s2 + s2 + s2;
		}
		long over = System.currentTimeMillis();
		System.out.println(" 操做字符串对象引用相加类型使用的时间为： " + (over - begin) + " 毫秒 ");
	}

	public void test3() {
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ttime; i++) {
			String s = "abadf" + "abadf" + "abadf";
		}
		long over = System.currentTimeMillis();
		System.out.println(" 操做字符串相加使用的时间为： " + (over - begin) + " 毫秒 ");
	}

	public static void main(String[] args) {
		String s1 = "abc";
		StringBuffer sb1 = new StringBuffer("abc");
		StringBuilder sb2 = new StringBuilder("abc");
		Test t = new Test();
		t.test(s1);
		t.test(sb1);
		t.test(sb2);
		t.test2();
		t.test3();
	}

试验结果以下：

 操做 java.lang.String 类型使用的时间为： 2432 毫秒 

 操做 java.lang.StringBuffer 类型使用的时间为： 3 毫秒 

 操做 java.lang.StringBuilder 类型使用的时间为： 3 毫秒 

 操做字符串对象引用相加类型使用的时间为： 6 毫秒 

 操做字符串相加使用的时间为： 1 毫秒 

把循环次数调的很大，试了用下jconsle来监视内存GC，第一次使用，不太明白，有个博客写的很好的，有空研究一下

 http://jiajun.iteye.com/blog/810150

再补充一个Jstat的工具 http://xiaolele.iteye.com/blog/592022

/**

*20120516昨天忘看源代码了

**/

StringBuffer中append方法有不少重载，有synchronized关键字没错，主要调用的仍是AbstractStringBuilder的super的方法。

public synchronized StringBuffer append(String s)
{
    super.append(s);
    return this;
}

父类的方法为

public AbstractStringBuilder append(String s) {

	if (s == null)
		s = "null";
	int i = s.length();
	if (i == 0)
		return this;
	int j = count + i;
	if (j > value.length)
		expandCapacity(j);
	s.getChars(0, i, value, count);
	count = j;
	return this;
}

StringBuilder类中的append就没有同步的关键字了。父类的方法基本上差很少。

总结一下，StringBuffer线程安全，内部有synchronized方法，StringBuilder是1.5以后出来的，高并发就不要用了。另外synchronized的使用要熟悉，之后研究下java内存的工具，好比jconsle。