String StringBuffer StringBuilder之间的区别

55 篇文章 3 订阅
相信大家看到过很多比较String和StringBuffer区别的文章,也明白这两者的区别,然而自从Java 5.0发布以后,我们的比较列表上将多出一个对象了,这就是StringBuilder类。String类是不可变类,任何对String的改变都会引发新的String对象的生成;而StringBuffer则是可变类,任何对它所指代的字符串的改变都不会产生新的对象,可变和不可变类这一对对象已经齐全了,那么为什么还要引入新的StringBuilder类干吗?相信大家都有此疑问,我也如此。下面,我们就来看看引入该类的原因。

      为什么会出现那么多比较String和StringBuffer的文章?

      原因在于当改变字符串内容时,采用StringBuffer能获得更好的性能。既然是为了获得更好的性能,那么采用StringBuffer能够获得最好的性能吗?

      答案是NO!

      为什么?

      如果你读过《Think in Java》,而且对里面描述HashTable和HashMap区别的那部分章节比较熟悉的话,你一定也明白了原因所在。对,就是支持线程同步保证线程安全而导致性能下降的问题。HashTable是线程安全的,很多方法都是synchronized方法,而HashMap不是线程安全的,但其在单线程程序中的性能比HashTable要高。StringBuffer和StringBuilder类的区别也在于此,新引入的StringBuilder类不是线程安全的,但其在单线程中的性能比StringBuffer高。

package cn.edu.lstc.stringbuffer;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class StringBuilderTest {
	private static final String base = "base string.";
	private static final int count = 2000000;

	/**
	 * 测试String类
	 */
	public static void stringTest() {
		long begin, end;
		begin = System.currentTimeMillis();// 开始时间
		String test = new String(base);
		for (int i = 0; i < count / 100; i++) {
			test = test + " add";
		}
		end = System.currentTimeMillis();// 结束时间
		System.out.println("当用String类来操作字符串时耗时:" + (end - begin) + "毫秒");
	}

	/**
	 * 测试StringBuffer类
	 */
	public static void stringBufferTest() {
		long begin, end;
		begin = System.currentTimeMillis();
		StringBuffer test = new StringBuffer(base);
		for (int i = 0; i < count; i++) {
			test = test.append(" add");
		}
		end = System.currentTimeMillis();
		System.out.println("当用StringBuffer来操作字符串时耗时:" + (end - begin) + "毫秒");
	}

	/**
	 * 测试StringBuilder类
	 */
	public static void stringBuilderTest() {
		long begin, end;
		begin = System.currentTimeMillis();// 开始时间
		StringBuilder test = new StringBuilder(base);
		for (int i = 0; i < count; i++) {
			test = test.append(" add");
		}
		end = System.currentTimeMillis();
		System.out.println("当用StringBuilder来操作字符串时耗时:" + (end - begin) + "毫秒");
	}

	public static String appendItemsToStringBuilder(List list) {
		StringBuilder builder = new StringBuilder();
		Iterator iterator = null;
		for (iterator = list.iterator(); iterator.hasNext();) {
			builder.append(iterator.next()).append(" ");
		}
		return builder.toString();
	}

	public static void addToStringBuilder() {
		List<String> list = new ArrayList<String>();
		list.add("I ");
		list.add(" play ");
		list.add(" Basketball ");
		list.add(" and ");
		list.add(" PingPongball ");

		System.out.println(StringBuilderTest.appendItemsToStringBuilder(list));
	}

	public static String appendItemsToStringBuffer(List list) {
		StringBuffer buffer = new StringBuffer();
		Iterator iterator = null;
		for (iterator = list.iterator(); iterator.hasNext();) {
			buffer.append(iterator.next()).append(" ");
		}
		return buffer.toString();
	}
	
	public static void addToStringBuffer(){
		List<String> list = new ArrayList<String>();
		list.add("I ");
		list.add(" play ");
		list.add(" Basketball ");
		list.add(" and ");
		list.add(" PingPongball ");

		System.out.println(StringBuilderTest.appendItemsToStringBuffer(list));
	}
	
	//主方法Main
	public static void main(String[] args) {
		stringTest();//
		
		stringBufferTest();
		
		stringBuilderTest();
		
		addToStringBuffer();
		
		addToStringBuilder();
	}
}

output:

当用String类来操作字符串时耗时:880毫秒
当用StringBuffer来操作字符串时耗时:70毫秒
当用StringBuilder来操作字符串时耗时:30毫秒
I   play   Basketball   and   PingPongball  
I   play   Basketball   and   PingPongball  

从上面的结果来看,这三个类在单线程程序中的性能差别一目了然,采用String对象时,即使运行次数仅是采用其他对象的1/100,其执行时间仍然比其他对象高出25倍以上;而采用StringBuffer对象和采用StringBuilder对象的差别也比较明显,前者是后者的1.5倍左右。由此可见,如果我们的程序是在单线程下运行,或者是不必考虑到线程同步问题,我们应该优先使用StringBuilder类;当然,如果要保证线程安全,自然非StringBuffer莫属了。

除了对多线程的支持不一样外,这两个类的使用几乎没有任何差别,上面的例子就是个很好的说明。appendItemsToStringBuiler和appendItemsToStirngBuffer两个方法除了采用的对象分别为StringBuilder和StringBuffer外,其他完全相同,而效果也完全相同。

1.三者在执行速度方面的比较: StringBuilder >  StringBuffer  >  String

  2.String <(StringBuffer,StringBuilder)的原因

    String:字符串常量

    StringBuffer:字符创变量

    StringBuilder:字符创变量

    从上面的名字可以看到,String是“字符创常量”,也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问  ,比如这段代码:

1  String s  =   " abcd " ;
2  =  s + 1 ;
3  System.out.print(s); //  result : abcd1

 

       我们明明就是改变了String型的变量s的,为什么说是没有改变呢? 其实这是一种欺骗,JVM是这样解析这段代码的:首先创建对象s,赋予一个abcd,然后再创建一个新的对象s用来    执行第二行代码,也就是说我们之前对象s并没有变化,所以我们说String类型是不可改变的对象了,由于这种机制,每当用String操作字符串时,实际上是在不断的创建新的对象,而原来的对象就会变为垃圾被GC回收掉,可想而知这样执行效率会有多底。

     而StringBuffer与StringBuilder就不一样了,他们是字符串变量,是可改变的对象,每当我们用它们对字符串做操作时,实际上是在一个对象上操作的,这样就不会像String一样创建一些而外的对象进行操作了,当然速度就快了。

  3.一个特殊的例子:

1  String str  =  “This is only a”  +  “ simple”  +  “ test”;
3  StringBuffer builder  =   new  StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

 

  

    你会很惊讶的发现,生成str对象的速度简直太快了,而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏,实际上:

    String str = “This is only a” + “ simple” + “test”;

    其实就是:

    String str = “This is only a simple test”;

    所以不需要太多的时间了。但大家这里要注意的是,如果你的字符串是来自另外的String对象的话,速度就没那么快了,譬如:

    String str2 = “This is only a”;

    String str3 = “ simple”;

    String str4 = “ test”;

    String str1 = str2 +str3 + str4;

    这时候JVM会规规矩矩的按照原来的方式去做。

  4.StringBuilder与 StringBuffer

    StringBuilder:线程非安全的

    StringBuffer:线程安全的

    当我们在字符串缓冲去被多个线程使用是,JVM不能保证StringBuilder的操作是安全的,虽然他的速度最快,但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作,所以大多数情况下是建议用StringBuilder而不用StringBuffer的,就是速度的原因。

 

           对于三者使用的总结: 1.如果要操作少量的数据用 = String

                        2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

                        3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

绝地反击T

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值