Java中的String,StringBuffer,StringBuilder

String

String是字符串常量，Java中String是immutable(不可变的)。

String类中的定义：

/** The value is used for character storage. */  private final char value[];        /** The offset is the first index of the storage that is used. */  private final int offset;        /** The count is the number of characters in the String. */  private final int count; 

用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。

StringBuffer

StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用StringBuffer，如果想转成String类型，可以调用StringBuffer的toString()方法。

Java.lang.StringBuffer线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将StringBuffer安全地用于多个线程。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。

StringBuilder

StringBuilder：字符串变量（非线程安全）。在内部，StringBuilder对象被当作是一个包含字符序列的变长数组。

java.lang.StringBuilder是一个可变的字符序列，是JDK5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

其构造方法如下：

构造方法描述StringBuilder()创建一个容量为16的StringBuilder对象（16个空元素）StringBuilder(CharSequence cs)创建一个包含cs的StringBuilder对象，末尾附加16个空元素StringBuilder(int initCapacity)创建一个容量为initCapacity的StringBuilder对象StringBuilder(String s)创建一个包含s的StringBuilder对象，末尾附加16个空元素

区别

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

使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。

看下面的例子

String tmp = "";for(int i = 0; i < 9999; tmp += "x"){}

String是一个支持非可变性的类，这种类的特点是状态固定（不存在任何修改对象的方法）。在该对象的生命周期内，他的值永远不变。所以当执行tmp+="x"的时候，实际上是另外创建了一个对象，而tmp原来指向的那个对象就成了垃圾（当它没有其他引用的时候），这样的话一个循环就会产生n个对象，从而造成内存的浪费。

将上例中的String改为StringBuffer就能解决此问题。

String与StringBuffer的效率比较

例1：

1.String result = "hello" + "world";

2.StringBuffer result = new StringBuffer().append("hello").append("world");

1的效率好于2！这是因为JVM会先进行“hello”+“world”处理，然后才赋值给result。只开辟了一次内存段。而第二句编译StringBuffer后还要做append处理，花的时间要长一些。

例2：

1.

public String getString(String s1, String s2){    return s1 + s2;}

2.

public String getString(String s1, String s2){    return new StringBuffer().append(s1).append(s2)}

1和2的效率一样，这是因为JVM会做如下处理。

开辟一个新的内存段再合并（扩展）内存——前者将s1和s2相加后赋值给新开辟的内存段，后者开辟内存段后将s1和s2拼接到后面，所以两者执行的过程是一致的。

例3：

1

String 是= “s1”s += "s2";s += "s3";

2

StringBuffer s = new StringBuffer().append("s1").append("s2").append("s3");

2的效率好于1，因为String是不可变对象，每次“+=”操作都会构造新的String对象。

例4：

1

StringBuffer s = new StringBuffer();for(int i = 0; i < 50000; i ++){    s.append("hello");}

2

StringBuffer s = new StringBuffer(250000);for(int i = 0; i < 50000; i ++){    s.append("hello");}

2的效率好于1，因为StringBuffer内部实现的是char数组，默认初始化长度为16，每当字符串长度大于char数组长度的时候，JVM会构造更大的新数组，并将原来的数组内容复制到新数组。2避免了复制数组的开销。

这里再说一下字符串对象的创建。由于字符串对象的大量使用（它是一个对象，一般而言对象总是在heap分配内存），Java中为了节省内存空间和运行时间（如比较字符串时，“==”比equals()快），在编译阶段就把所有的字符串文字放到一个文字池(pool of literal strings)中，而运行时文字池成为常量池的一部分。文字池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。

String s1 = "abc";String s2 = "abc";System.out.println(s1==s2);

返回true，表明两个字符串文字保存为一个对象。就是说，上面的代码只在pool中创建了一个String对象。

现在看“String s = new String("abc");”语句，这里“abc”本身就是pool中的一个对象，而在运行是执行new String()时，将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。所以这条语句就创建了两个String对象

例子：

String A，B，C;A = “a”;B = "b";A = A + B;StringBuffer D = new StringBuffer("abc");D = D.append("567");

A = "a";此处创建了一个对象及一个引用A

B = "b";与上一句类似

A = A + B;此处创建了一个对象，并由引用A来引用，那么原来A所指向的对象就成为垃圾对象，被回收

StringBuffer D = new StringBuffer("abc");这一句创建了两个对象

D = D.append("567");都是对同一个对象进行处理，所以这一句并没有创建对象。

综上所述，这个例子总共创建了5个对象。

字符串的+操作其本质是创建了StringBuilder对象进行append操作，然后将拼接后的StringBuilder对象用toString方法处理成String对象

再看一个StringBuffer的例子

public class B{    public static void main(String[] args) {        StringBuffer a = new StringBuffer("A");        StringBuffer b = new StringBuffer("B");        operate(a,b);        System.out.println(a+","+b);    }    private static void operate(StringBuffer x, StringBuffer y) {        x.append(y);        y = x;    }}

程序输出的是

AB，B

解析

operate函数传入两个StringBuffer类型的句柄的副本。（此处也能看出，Java函数中的参数其实传的就是句柄的副本）。一个是x，一个是y，分别指向A，B

执行“x.append(y);”后，AB附加在一起，而指针x和y没有发生变化。

执行“y=x;"后，y指向AB。

函数结束后，x和y自然消亡。a指向的是AB，b指向的是B。

String,StringBuffer,StringBuilder的使用策略：

（1）基本原则：如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffer。

（2）不要使用String类的"+"来进行频繁的拼接，因为那样的性能极差的，应该使用StringBuffer或StringBuilder类，这在Java的优化上是一条比较重要的原则。例如：

String result = "";for (String s : hugeArray) {    result = result + s;}// 使用StringBuilderStringBuilder sb = new StringBuilder();for (String s : hugeArray) {    sb.append(s);}String result = sb.toString();

当出现上面的情况时，显然我们要采用第二种方法，因为第一种方法，每次循环都会创建一个String result用于保存结果，除此之外二者基本相同（对于jdk1.5及之后版本）。

（3）为了获得更好的性能，在构造 StringBuffer 或 StringBuilder 时应尽可能指定它们的容量。当然，如果你操作的字符串长度（length）不超过 16 个字符就不用了，当不指定容量（capacity）时默认构造一个容量为16的对象。不指定容量会显著降低性能。

（4）StringBuilder一般使用在方法内部来完成类似"+"功能，因为是线程不安全的，所以用完以后可以丢弃。StringBuffer主要用在全局变量中。

（5）相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非确定系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，才可以采用StringBuilder；否则还是用StringBuffer。

参考资料：http://blog.csdn.net/kingzone_2008/article/details/9220691