String,StringBuffer,StringBuilder之间的异同

一，了解String对象
二，StringBuffer对象与String的区别和好处
三，StringBuilder的优点

我们知道String不是八种基本数据类型，那它是怎么存储字符串的?
我们来看一下源码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {}

String是final的，不可被继承。并且它创建的对象一旦被创建就不能被改变了（后面给予代码证明）。

 private final char value[];

里面定义了char数组来存储Value，所以我们知道了，String原来是用char来存储字符串的。

我们都知道String可以有两种方法定义：
String str = “”；
String str = new String (“”);

那么你知道String str = new String(“java”);是创建了几个字符创？
是两个，一个是new String（”），一个是“java”，因为在jvm初始化的时候创建了“java”字符串，然后new 使得String构造函数将str的引用指向new出来新字符创（根据“java”构造出的新字符串）。

package testJavaSE;

public class testString {
    public static void change(String text) {
        text.replace("j", "i");

    }
    public static void main(String[] args) {
        String str = new String("java");
        System.out.println(str);
        change(str);
        System.out.println(str);
    }
}

猜猜输出什么？
如果你说输出：
java
iava
那你就错了，应该是输出：
java
java
为什么？就是因为String对象是不可变对象，它的所有方法（在原有的字符串上操作）都会产生一个新的对象，所以我们输出的对象依旧是原来的对象。

虽然改变了“原来的对象”，但是原来的对象没变，而是又生成了一个字符创对象。
我们将上面的代码改进一下：

package testJavaSE;

public class testString2 {
    public static String change(String text) {
        return text.replace("j","i");

    }
    public static void main(String[] args) {
        String oldstr = new String("java");
        System.out.println("old:"+oldstr);
        String newstr = change(oldstr);
        System.out.println("new:"+newstr);
    }

}

这段代码输出的就是：
old:java
new:iava
（具体为什么产生新的对象，参考String方法源码）

二，接下来我们来看看StringBuffer，和String不同StringBuffer是可变的(它的所有属性不是final的)，也就是不像String那样在原有的字符创上更改会产生新的字符串。

//StringBuffer的定义
public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{...}

我们下面先来看看两段代码的比较：

package testJavaSE;

public class testString3 {
    public static void main(String[] args) {
        String str="";
        String tmp="abcdefghijklmnopqrstuvwxyz";
        long startTime = System.currentTimeMillis();
        for(int i=0;i<10000;i++) {
            str+=tmp;
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }
}
//输出：1705（不同的电脑输出不同）

package testJavaSE;

public class testStringBuffer {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
        String tmp="abcdefghijklmnopqrstuvwxyz";
        long startTime = System.currentTimeMillis();
        for(int i=0;i<10000;i++) {
            str.append(tmp);
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }
}
//输出：2

同样都是添加字符串，StringBuffer的效率是String的1000倍（运算次数越大差距越明显）。就是因为StringBuffer不会创建那么多的对象，而String在改变字符串的同时会浪费大量的时间来创建新的字符串。

//StringBuffer也是由char数组来存储数据的
private transient char[] toStringCache;

  //它的初始化大小为16，如果超出容量，有方法对它扩容
public StringBuffer() {
        super(16);
    }

//它也可以由我们自己定义数组的大小
public StringBuffer(int capacity) {
        super(capacity);
    }
//在创建一个StringBuffer的时候，它的大小为传进str大小+16
public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

public synchronized int length() {
        return count;
    }

    @Override
    public synchronized int capacity() {
        return value.length;
    }


    @Override
    public synchronized void ensureCapacity(int minimumCapacity) {
        super.ensureCapacity(minimumCapacity);
    }

    /**
     * @since      1.5
     */
    @Override
    public synchronized void trimToSize() {
        super.trimToSize();
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @see        #length()
     */
    @Override
    public synchronized void setLength(int newLength) {
        toStringCache = null;
        super.setLength(newLength);
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @see        #length()
     */
    @Override
    public synchronized char charAt(int index) {
        if ((index < 0) || (index >= count))
            throw new StringIndexOutOfBoundsException(index);
        return value[index];
    }
.
.
.
.
.
//它的方法都是带有synchronized关键字的所以它是线程安全的。

总结：String是不可变的，StringBuffer是可变的，且是线程安全的。

三，我们再来看看StringBuilder：

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{..}

这个家伙是不是似曾相识?
它和StingBuffer几乎相同，都继承了相同的父类实现相同的接口。
初始大小都是16，同样可以自动扩容，但它的方法不带有synchronized的关键字，所以如果是单机，或者不涉及到多线程的操作使用StingBuilder效率更高，若设计到多线程和线程安全则建议使用StringBuffer。
效率：
　　StringBuilder > StringBuffer > String

　　当然这个是相对的，不一定在所有情况下都是这样。

　　比如String str = “hello”+ “world”的效率就比 StringBuilder st = new StringBuilder().append(“hello”).append(“world”)要高。

　　因此，这三个类是各有利弊，应当根据不同的情况来进行选择使用：

　　当字符串相加操作或者改动较少的情况下，建议使用 String str=”hello”这种形式；

　　当字符串相加操作较多的情况下，建议使用StringBuilder，如果采用了多线程，则使用StringBuffer。