String、StringBuffer、StringBuilder的区别？

参考：http://www.cnblogs.com/xudong-bupt/p/3961159.html
http://blog.csdn.net/mad1989/article/details/26389541
1、StringBuffer、StringBuilder和String一样，也用来代表字符串

2、区别

①String类是不可变类，任何对String的改变都 会引发新的String对象的生成

②StringBuffer、StringBuilder是可变类，任何对它所指代的字符串的改变都不会产生新的对象

③StringBufferd支持并发操作，线性安全的，适 合多线程中使用

④StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。

⑤新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。

3、源码分析， string源码

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];

/** Cache the hash code for the string */
private int hash; // Default to 0

/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;

/**
* Class String is special cased within the Serialization Stream Protocol.
*
* A String instance is written initially into an ObjectOutputStream in the
* following format:
* <pre>
*      <code>TC_STRING</code> (utf String)
* </pre>
* The String is written by method <code>DataOutput.writeUTF</code>.
* A new handle is generated to  refer to all future references to the
* string instance within the stream.
*/
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];

/**
* Initializes a newly created {@code String} object so that it represents
* an empty character sequence.  Note that use of this constructor is
* unnecessary since Strings are immutable.
*/
public String() {
this.value = new char[0];
}

String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。

　private final char value[];

4、源码分析， StringBuilder与StringBuffer源码

StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。

* @author      Michael McCloskey
* @see         java.lang.StringBuffer
* @see         java.lang.String
* @since       1.5
*/
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{

/** use serialVersionUID for interoperability */
static final long serialVersionUID = 4383685877147921099L;

/**
* Constructs a string builder with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuilder() {
super(16);
}

* @author      Arthur van Hoff
* @see     java.lang.StringBuilder
* @see     java.lang.String
* @since   JDK1.0
*/
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{

/** use serialVersionUID from JDK 1.0.2 for interoperability */
static final long serialVersionUID = 3388685877147921107L;

/**
* Constructs a string buffer with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuffer() {
super(16);
}

* @author      Martin Buchholz
* @author      Ulf Zibis
* @since       1.5
*/
abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
char[] value;

/**
* The count is the number of characters used.
*/
int count;

/**
* This no-arg constructor is necessary for serialization of subclasses.
*/
AbstractStringBuilder() {
}

/**
* Creates an AbstractStringBuilder of the specified capacity.
*/
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}

5、线程安全问题

String中的对象是不可变的，也就可以理解为常量，显然线程安全。

StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。

StringBuilder不支持并发操作，线程不安全的，不适合多线程中使用





6、在单线程下的性能测试

package com.py.string_strbuffer_strbuilder;

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

public class StringTest {

public static String INIT = "Hello World";
public static final int COUNT = 2000000;

/**
* 执行一项String赋值测试
*/
public static void doStringTest() {

String str = new String(INIT);
long starttime = System.currentTimeMillis();
//此处如果直接COUNT，几分钟都不了结果
for (int i = 0; i < COUNT/100; i++) {
str = str + "miss";
}
long endtime = System.currentTimeMillis();
System.out.println((endtime - starttime)
+ " millis(毫秒) has costed when used String.");
}

/**
* 执行一项StringBuffer赋值测试
*/
public static void doStringBufferTest() {

StringBuffer sb = new StringBuffer(INIT);
long starttime = System.currentTimeMillis();
for (int i = 0; i < COUNT; i++) {
sb = sb.append("miss");
}
long endtime = System.currentTimeMillis();
System.out.println((endtime - starttime)
+ " millis(毫秒) has costed when used StringBuffer.");
}

/**
* 执行一项StringBuilder赋值测试
*/
public static void doStringBuilderTest() {

StringBuilder sb = new StringBuilder(INIT);
long starttime = System.currentTimeMillis();
for (int i = 0; i < COUNT; i++) {
sb = sb.append("miss");
}
long endtime = System.currentTimeMillis();
System.out.println((endtime - starttime)
+ " millis(毫秒) has costed when used StringBuilder.");
}

/**
* 测试StringBuffer遍历赋值结果
*
* @param mlist
*/
public static void doStringBufferListTest(List<String> mlist) {
StringBuffer sb = new StringBuffer();
long starttime = System.currentTimeMillis();
for (String string : mlist) {
sb.append(string);
}
long endtime = System.currentTimeMillis();
System.out.println(sb.toString() + "buffer cost:"
+ (endtime - starttime) + " millis(毫秒)");
}

/**
* 测试StringBuilder迭代赋值结果
*
* @param mlist
*/
public static void doStringBuilderListTest(List<String> mlist) {
StringBuilder sb = new StringBuilder();
long starttime = System.currentTimeMillis();
for (Iterator<String> iterator = mlist.iterator(); iterator.hasNext();) {
sb.append(iterator.next());
}

long endtime = System.currentTimeMillis();
System.out.println(sb.toString() + "builder cost:"
+ (endtime - starttime) + " millis(毫秒)");
}

public static void main(String[] args) {
doStringTest();
doStringBufferTest();
doStringBuilderTest();

List<String> list = new ArrayList<String>();
list.add("I ");
list.add("like ");
list.add("java ");
list.add("and ");
list.add("android ");
list.add("android ");
list.add("android ");
list.add(". ");

doStringBufferListTest(list);
doStringBuilderListTest(list);
}

}

7、结果：StringBuilder > StringBuffer > String

764 millis(毫秒) has costed when used String.

78 millis(毫秒) has costed when used StringBuffer.

47 millis(毫秒) has costed when used StringBuilder.

I like java and android android android . buffer cost:0 millis(毫秒)

I like java and android android android . builder cost:0 millis(毫秒)

8、结论：

不必考虑到线程同步问题，我们应该优先使用StringBuilder类；如果要保证线程安全，自然是StringBuffer。普通情况用String

9、StringBuffer常用方法

（由于StringBuffer和StringBuilder在使用上几乎一样，所以只写一个）

StringBuffer s = new StringBuffer();

这样初始化出的StringBuffer对象是一个空的对象，

 StringBuffer sb1=new StringBuffer(512);

分配了长度512字节的字符缓冲区。 

StringBuffer sb2=new StringBuffer(“how are you?”)

创建带有内容的StringBuffer对象，在字符缓冲区中存放字符串“how are you?”

 a、append方法

public StringBuffer append(boolean b)

该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接，调用该方法以后，StringBuffer对象的内容也发生改 变，例如：

StringBuffer sb = new StringBuffer(“abc”);

sb.append(true);

则对象sb的值将变成”abctrue”

使用该方法进行字符串的连接，将比String更加节约内容，经常应用于数据库SQL语句的连接。

 b、deleteCharAt方法

public StringBuffer deleteCharAt(int index)

该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如：

StringBuffer sb = new StringBuffer(“KMing”);

sb. deleteCharAt(1);

该代码的作用删除字符串对象sb中索引值为1的字符，也就是删除第二个字符，剩余的内容组成一个新的字符串。所以对象sb的值变 为”King”。

还存在一个功能类似的delete方法：

public StringBuffer delete(int start,int end)

该方法的作用是删除指定区间以内的所有字符，包含start，不包含end索引值的区间。例如：

StringBuffer sb = new StringBuffer(“TestString”);

sb. delete (1,4);

该代码的作用是删除索引值1(包括)到索引值4(不包括)之间的所有字符，剩余的字符形成新的字符串。则对象sb的值是”TString”。 

 c、insert方法

public StringBuffer insert(int offset, boolean b),

该方法的作用是在StringBuffer对象中插入内容，然后形成新的字符串。例如：

StringBuffer sb = new StringBuffer(“TestString”);

sb.insert(4,false);

该示例代码的作用是在对象sb的索引值4的位置插入false值，形成新的字符串，则执行以后对象sb的值是”TestfalseString”。 

 d、reverse方法

public StringBuffer reverse()

该方法的作用是将StringBuffer对象中的内容反转，然后形成新的字符串。例如：

StringBuffer sb = new StringBuffer(“abc”);

sb.reverse();

经过反转以后，对象sb中的内容将变为”cba”。 

 e、setCharAt方法

public void setCharAt(int index, char ch)该方法的作用是修改对象中索引值为index位置的字符为新的字符ch。例如：

StringBuffer sb = new StringBuffer(“abc”);

sb.setCharAt(1,’D’);

则对象sb的值将变成”aDc”。 

 f、trimToSize方法

public void trimToSize()

该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费，和String的trim()是一样的作用，不在举例。

 g、length方法

该方法的作用是获取字符串长度 ，不用再说了吧。

 h、setlength方法

该方法的作用是设置字符串缓冲区大小。

StringBuffer sb=new StringBuffer();

sb.setlength(100);

如果用小于当前字符串长度的值调用setlength()方法，则新长度后面的字符将丢失。 

 i、sb.capacity方法

该方法的作用是获取字符串的容量。

StringBuffer sb=new StringBuffer(“string”);

int i=sb.capacity(); 

 j、ensureCapacity方法

该方法的作用是重新设置字符串容量的大小。

StringBuffer sb=new StringBuffer();

sb.ensureCapacity(32); //预先设置sb的容量为32 

 k、getChars方法

该方法的作用是将字符串的子字符串复制给数组。

getChars(int start,int end,char chars[],int charStart); 

StringBuffer sb = new StringBuffer("I love You");
int begin = 0;
int end = 5;
//注意ch字符数组的长度一定要大于等于begin到end之间字符的长度
//小于的话会报ArrayIndexOutOfBoundsException
//如果大于的话，大于的字符会以空格补齐
char[] ch  = new char[end-begin];
sb.getChars(begin, end, ch, 0);
System.out.println(ch);

结果：I lov