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

2019独角兽企业重金招聘Python工程师标准>>>

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

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

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

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

 

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

3、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。

 

转载于:https://my.oschina.net/zimingforever/blog/57514