String、StringBuffer和StringBuilder

一、String和StringBuffer

        String类型和StringBuffer类型的主要性能区别其实在于String是不可变的对象，因此在每次对String类型进行改变的时候其实都等同于生成了一个新的String对象，然后将指针指向新的String对象，所以经常改变内容的字符串最好不要用String，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象对了以后，JVM的GC就会开始工作，那速度是一定会相当慢的。

具体说原理的话，两个字符串相加，相当于执行了如下操作：

Str1+str2执行了下面的过程：

StringBuffer sb1 = new StringBuffer（str1）；

sb1.append(str2);

String result1 = sb1.toString();

执行到最后，我们所需要的内容只有result1这一个对象，中间出现的sb1就成为了垃圾回收的目标。

此时，如果我们再加一个字符串的话……

str1+str2+str3相当于在上面的基础上又执行了

StringBuffersb2 = new StringBuffer(result1);

sb2.append(str3);

String result2 = sb2.toString();

这时，对我们有用的对象只有result2一个中间生成的对象都成为了垃圾回收的目标。如果继续追加下去，又会产生若干个StringBuffer的垃圾对象和String的垃圾对象。

而如果是使用Stringbuffer类则结果就不一样了，每次结果都会对StringBuffer对象本身进行操作，而不是生成新的对象，再改变对象引用。

StringBuffersb = new StringBuffer();

sb.append(str1);

sb.append(str2);

……

sb.append(strN);

String result = sb.toString();

除了中间的一个StringBuffer对象最后会被弃掉，其他的都是有效对象，效率自然会高。

package SE.AboutString;

import java.util.Calendar;

/**
 * 
 * <p>
 * Description: 测试String和StringBuffer的效率
 * </p>
 * @author zhangjunshuai
 * @version 1.0
 * Create Date: 2014-7-7 下午5:25:57
 * Project Name: UseTest
 *
 * <pre>
 * Modification History: 
  *             Date                                Author                   Version          Description 
 * -----------------------------------------------------------------------------------------------------------  
 * LastChange: $Date::             $      $Author: $          $Rev: $         
 * </pre>
 *
 */
public class StringMerger {
	
	public static String merge(String[] strings, String separator, boolean isSepAtTail) {
		if (strings == null) {
			return null; 
		}
		if (separator == null) {
			separator = ""; 
		}
		
		String mergedString = new String(); 
		for (int i = 0; i < strings.length - 1; i++) {
			mergedString += (strings[i] + separator); 
		}
		
		mergedString += strings[strings.length - 1]; 
		if (isSepAtTail) {
			mergedString += separator; 
		}
		
		return mergedString; 
	}
	
	
	public static String bufferMerge(String[] strings, String separator, boolean isSepAtTail) {
		if (strings == null) {
			return null; 
		}
		if (separator == null) {
			separator = ""; 
		}
		
		StringBuffer mergeSb = new StringBuffer(); 
		for (int i = 0; i < strings.length - 1; i++) {
			mergeSb.append(strings[i]).append(separator); 
		}
		
		mergeSb.append(strings[strings.length - 1]); 
		if (isSepAtTail) {
			mergeSb.append(separator); 
		}
		
		return mergeSb.toString(); 
	}
	
	public static void main(String[] args) {
		// call the two methods to initialize the class and methods. 
		System.out.println(StringMerger.merge(new String[] {"a", "kk", "ef"}, " ^_^ ", false)); 
		System.out.println(StringMerger.bufferMerge(new String[] {"a", "kk", "ef"}, " ^_^ ", false));
		
		final int n = 10000;
		final String sep = System.getProperty("line.separator");
		
		// create an array of String for merging.  
		String[] forMerge = new String[n]; 
		for (int i = 0; i < n; i++) {
			forMerge[i] = Integer.toBinaryString(i); 
		}
		
		// declare two variables to store start time and end time. 
		long startTime = 0; 
		long endTime = 0; 
		
		// run the test code 5 times. 
		for (int i = 0; i < 5; i++) {
			System.out.println("==="); 
			
			// get current time as start time. 
			startTime = Calendar.getInstance().getTimeInMillis();
			// merge string by using String. 
			StringMerger.bufferMerge(forMerge, sep, false);
			// get current time as end time. 
			endTime = Calendar.getInstance().getTimeInMillis();
			// print out the result. 
			System.out.println("merge by StringBuffer start: " + startTime);
			System.out.println("merge time: " + (endTime - startTime)); 
			System.out.println("merge by StringBuffer end: " + endTime);
			
			// get current time as start time. 
			startTime = Calendar.getInstance().getTimeInMillis();
			// merge string by using StringBuffer. 
			StringMerger.merge(forMerge, sep, false);
			// get current time as end time. 
			endTime = Calendar.getInstance().getTimeInMillis();
			// print out the result. 
			System.out.println("merge by String start: " + startTime);
			System.out.println("merge time: " + (endTime - startTime)); 
			System.out.println("merge by String end: " + endTime);
		}
	}
}

二、关于线程安全

线程安全就是多个线程修改同一个对象时可能产生的冲突问题。比如有一个StringBuilder对象，变量名为stringBuffer，在一个线程里执行stringBuffer.append("0")的同时，另外一个线程也执行同样的代码，就有可能出现无法预料的问题。出现问题的原因是在StringBuilder的append方法中，不是只有一条语句，而是由若干语句。当进程A进入append（）函数时，另一个线程B可能在其中任意一条语句之后就进入这个函数，从而再次执行函数中第一条语句，而接下来执行线程A中即将继续执行的语句还是执行线程B中即将执行的第二句谁也说不清。

        实际剖析一下，可以看到StringBuilder里面实际执行的语句如下（实际是执行父类的内容）

if(str == null) str = "null";

intlen = str.length();

ensureCapacityInternal(count+ len);

str.getChars(0,len, value, count);

count+= len;

returnthis;

假设StringBuilder对象中的字符串长度为10，也就是count为10，我们追加的字符串为“0”，也就是长度为1.如果当线程A执行到count+=len时候，恰好线程B的代码进入函数，并且取得运行权一直到结束，此时在线程B中的count因为加上了“0”的长度，为11.现在线程A再次开始执行，因为count的定义没有volatile关键字，所以很有可能线程A中的count还是之前的10，所以再次执行语句时候，让count变成11.结果命名之行了两次append()函数，count却只增加了1.显然与期望逻辑不符。

由此可知StringBuffer是线程安全的可变字符序列。可将字符串缓冲区安全的用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。StringBuffer上的主要操作时append和insert方法，可重载这些方法，以接受任意的类型的数据。每个方法都能效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append方法始终将这些字符添加到缓冲区的末端；而inert方法则在指定的点添加字符。

StringBuffer是一个可变的字符序列是5.0新增的，此类提供一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，简易优先采用该类，因为在大多数实现中，它比StringBuffer要快。两者的方法基本相同。

package SE.AboutString;

import java.util.Random;

public class StringBufferVsStringBuilder {
	public static int demo(final Object stringJoiner, final int testCount) throws InterruptedException {
		ThreadGroup group = new ThreadGroup(stringJoiner.getClass().getName() + "@" + stringJoiner.hashCode()); 
		final Random rand = new Random(); 
		
		Runnable listAppender = new Runnable() {
			public void run() {
				try {
					Thread.sleep(rand.nextInt(2));
				} catch (InterruptedException e) {
					return; 
				} 
				if (stringJoiner instanceof StringBuffer) {
					((StringBuffer)stringJoiner).append("0");
				} else if (stringJoiner instanceof StringBuilder) {
					((StringBuilder)stringJoiner).append("0"); 
				}
			}
		}; 
		
		for (int i = 0; i < testCount; i++) {
			new Thread(group, listAppender, "InsertList-" + i).start(); 
		}
		
		while (group.activeCount() > 0) {
			Thread.sleep(10); 
		}
		
		return stringJoiner.toString().length(); 
	}
	
	public static void main(String[] args) throws InterruptedException {
		StringBuilder stringBuilder = new StringBuilder();
		StringBuffer stringBuffer = new StringBuffer();
		final int N = 10000; 
		for (int i = 0; i < 10; i++) {
			stringBuilder.delete(0, stringBuilder.length()); 
			stringBuffer.delete(0, stringBuffer.length()); 
			int builderLength = demo(stringBuilder, N); 
			int bufferLength = demo(stringBuffer, N); 
			System.out.println("StringBuilder/StringBuffer: " + builderLength + "/" + bufferLength); 
		}
	}
}


// Output will be something like this:
// StringBuilder/StringBuffer: 9995/10000
// StringBuilder/StringBuffer: 9996/10000
// StringBuilder/StringBuffer: 9998/10000
// StringBuilder/StringBuffer: 9997/10000
// StringBuilder/StringBuffer: 9995/10000
// StringBuilder/StringBuffer: 9996/10000
// StringBuilder/StringBuffer: 9998/10000
// StringBuilder/StringBuffer: 9998/10000
// StringBuilder/StringBuffer: 9999/10000
// StringBuilder/StringBuffer: 9999/10000

package SE.AboutString;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class ThreadSafeDemo {
	public static int demo(final List list, final int testCount) throws InterruptedException {
		ThreadGroup group = new ThreadGroup(list.getClass().getName() + "@" + list.hashCode()); 
		final Random rand = new Random(); 
		
		Runnable listAppender = new Runnable() {
			public void run() {
				try {
					Thread.sleep(rand.nextInt(2));
				} catch (InterruptedException e) {
					return; 
				} 
				list.add("0"); 
			}
		}; 
		
		for (int i = 0; i < testCount; i++) {
			new Thread(group, listAppender, "InsertList-" + i).start(); 
		}
		
		while (group.activeCount() > 0) {
			Thread.sleep(10); 
		}
		
		return list.size(); 
	}
	public static void main(String[] args) throws InterruptedException {
		List unsafeList = new ArrayList(); 
		List safeList = Collections.synchronizedList(new ArrayList()); 
		final int N = 10000; 
		for (int i = 0; i < 10; i++) {
			unsafeList.clear(); 
			safeList.clear(); 
			int unsafeSize = demo(unsafeList, N); 
			int safeSize = demo(safeList, N); 
			System.out.println("unsafe/safe: " + unsafeSize + "/" + safeSize); 
		}
	}
}

/*unsafe/safe: 9896/10000
unsafe/safe: 9931/10000
unsafe/safe: 9940/10000
unsafe/safe: 9912/10000
unsafe/safe: 9960/10000
unsafe/safe: 9954/10000
unsafe/safe: 9960/10000
unsafe/safe: 9944/10000
unsafe/safe: 9960/10000
unsafe/safe: 9957/10000*/

http://www.zhihu.com/question/20101840

http://blog.csdn.net/rmn190/article/details/1492013