java StringBuffer StringBulider 区别

StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）

String 类型和 StringBuffer 、StringBuilder 类型的主要性能区别其实在于 String 是不可变的对象，而后俩者都是可变的。

来看看 StringBuffer类源码定义：

Java代码

2. public final class StringBuffer
3. extends AbstractStringBuilder
4. implements java.io.Serializable, CharSequence
5. {
7. public StringBuffer() {
8. super(16);
9. }
11. public StringBuffer(int capacity) {
12. super(capacity);
13. }

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

    public StringBuffer() {
	super(16);
    }

     public StringBuffer(int capacity) {
	super(capacity);
    }

上例代码我们发现 StringBuffer 继承了 AbstractStringBuilder抽象类。包括构造方法的实现，都是父类提供的。

然后，我们打开 StringBuilder源码定义：

Java代码

1. public final class StringBuilder
2. extends AbstractStringBuilder
3. implements java.io.Serializable, CharSequence
4. {
6. public StringBuilder() {
7. super(16);
8. }
10. public StringBuilder(int capacity) {
11. super(capacity);
12. }

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

    public StringBuilder() {
	super(16);
    }

    public StringBuilder(int capacity) {
	super(capacity);
    }

我们发现两者都继承了AbstractStringBuilder抽象类。且构造方法都调用父类实现。

我们接着看两者append方法实现：

先看StringBuffer的：

Java代码

2. public synchronized StringBuffer append(Object obj) {
3. super.append(String.valueOf(obj));
4. return this;
5. }
7. public synchronized StringBuffer append(String str) {
8. super.append(str);
9. return this;
10. }
11. //...

   
 public synchronized StringBuffer append(Object obj) {
        super.append(String.valueOf(obj));
        return this;
    }

    public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
    }
    //...

再看StringBuilder的：

Java代码

1. public StringBuilder append(Object obj) {
2. return append(String.valueOf(obj));
3. }
5. public StringBuilder append(String str) {
6. super.append(str);
7. return this;
8. }
9. //...

    
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    //...

对比上面两段源码 我们发现 StirngBuffer 和StringBuilder的 append实现都是调用父类实现的。唯一不同的是 StringBuffer是线程安全的，方法中多了synchronized ，而StringBuilder 是非线程安全的。

我们看下父类AbstractStringBuilder 定义 及 append 实现：

Java代码

1. abstract class AbstractStringBuilder implements Appendable, CharSequence {
2. //底层与String类一样都是 char类型数组。
3. char value[];
4. //字符串长度
5. int count;
7. AbstractStringBuilder() {
8. }
10. AbstractStringBuilder(int capacity) {
11. value = new char[capacity];
12. }

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    //底层与String类一样都是 char类型数组。
    char value[];
    //字符串长度
    int count;

    AbstractStringBuilder() {
    }

    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

Java代码

1. public AbstractStringBuilder append(Object obj) {
2. return append(String.valueOf(obj));
3. }
5. public AbstractStringBuilder append(String str) {
6. //对于str==null的
7. if (str == null) str = "null";
8. int len = str.length();
9. if (len == 0) return this;
10. //新的字符串长度
11. int newCount = count + len;
12. if (newCount > value.length)
13. //当新的字符串长度比原先数组长度大时，需要对char 数组扩容。
14. expandCapacity(newCount);
15. //将新添的数据追加到char类型数组中。
16. str.getChars(0, len, value, count);
17. count = newCount;
18. return this;
19. }
21. //数组扩容
22. void expandCapacity(int minimumCapacity) {
23. //先扩容成 (原先的长度+1）*2
24. int newCapacity = (value.length + 1) * 2;
25. //判断newCapacity值是否满足要求
26. //如果新的长度还是不够，则直接取值 minimumCapacity
27. if (newCapacity < 0) {
28. newCapacity = Integer.MAX_VALUE;
29. } else if (minimumCapacity > newCapacity) {
30. newCapacity = minimumCapacity;
31. }
32. char newValue[] = new char[newCapacity];
33. //将原先的数据拷贝到新的char 数组中。
34. System.arraycopy(value, 0, newValue, 0, count);
35. value = newValue;
36. }
38. public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
39. if (srcBegin < 0) {
40. throw new StringIndexOutOfBoundsException(srcBegin);
41. }
42. if (srcEnd > count) {
43. throw new StringIndexOutOfBoundsException(srcEnd);
44. }
45. if (srcBegin > srcEnd) {
46. throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
47. }
48. System.arraycopy(value, offset + srcBegin, dst, dstBegin,
49. srcEnd - srcBegin);
50. }

StringBuffer与StringBuilder是java.lang包下被大家熟知的两个类。其异同为：一、长度都是可扩充的；二、StringBuffer是线程安全的，StringBuilder是线程不安全的。那么他们的长度是如何实现动态扩充以及StringBuffer的线程安全是如何实现的呢？通过“深度”阅读它们的源代码，最终弄明白其中的缘由。

正文

首先上一张StringBuffer和StringBuilder类结构图：

抽象类AbstractStringBuilder（也是核心实现类）实现了Appendable和CharSequence两个接口；StringBuffer与StringBuilder统统继承自AbstractStringBuilder，并且实现了java.io.Serializable和CharSequence接口。

下面简单描述下这几个接口所起到的作用(引用自中文api)。

• Appendable：能够被添加 char 序列和值的对象。如果某个类的实例打算接收java.util.Formatter 的格式化输出，那么该类必须实现 Appendable 接口

。要添加的字符应该是有效的 Unicode 字符，正如 Unicode Character Representation 中描述的那样。注意，增补字符可能由多个 16 位char 值组成

• CharSequence：CharSequence 是 char 值的一个可读序列。此接口对许多不同种类的 char 序列提供统一的只读访问。char 值表示 Basic Multilingual Plane (BMP) 或代理项中的一个字符。有关详细信息，请参阅 Unicode 字符表示形式。此接口不修改 equals 和 hashCode 方法的常规协定。因此，通常未定义比较实现 CharSequence 的两个对象的结果。每个对象都可以通过一个不同的类实现，而且不能保证每个类能够测试其实例与其他类的实例的相等性。因此，使用任意 CharSequence 实例作为集合中的元素或映射中的键是不合适的。

• Serializable：类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

• AbstractStringBuilde

r这个抽象类提供了StringBuffer和StringBuilder绝大部分的实现。在AbstractStringBuilder的描述中说：如果去掉线程安全，那么StringBuffer和StringBuilder是完全一致的。从实现的角度来说，StringBuffer所有方法(构造方法除外，因为没有必要)签名中都使用synchronized限定，也就是所有的方法都是同步的。

eg.StringBuffer中replace()方法

view source print ?

1	public synchronized StringBuffer replace(int start, int end, String str) {

2	super.replace(start, end, str);

3	return this;

4

}

StringBuilder中replace()：

view source print ?

1	public StringBuilder replace(int start, int end, String str) {

2	super.replace(start, end, str);

3	return this;

4

}

区别仅仅在方法签名上是否有synchronized。

另外需要稍稍注意的问题是：StringBuffer同步只同步目标，比如：sb.append("i am not synchronized"),sb是同步的，而其中的参数未必是同步的。

而它们两个可扩展长度则是通过ensureCapacity(int minimumCapacity)来验证当前长度是否小于参数minimumCapacity，如果成立则进行分配空间。分配新空间的步长为（当前长度+1）的两倍。

实现如下：

view source print ?

01	public void ensureCapacity(int minimumCapacity) {

02	if (minimumCapacity > value.length) {

03	expandCapacity(minimumCapacity);

04

}

05

}

06	void expandCapacity(int minimumCapacity) {

07	int newCapacity = (value.length + 1) * 2;

08	if (newCapacity < 0) {

09	newCapacity = Integer.MAX_VALUE;

10	} else if (minimumCapacity > newCapacity) {

11	newCapacity = minimumCapacity;

12

}

13	value = Arrays.copyOf(value, newCapacity);

14

}

如果新的长度小于0(溢出了)，则使用Integer的最大值作为长度。

另外，在阅读源码的过程中，发现两个有趣的问题，下面一一道来。

第一个，就是reverse的实现。其实我是第一次看StringBuilder和StringBuffer的源码，这里面的reverse的实现是我所知道的java中的最高效的实现，没有之一。

上源码，再做解释：

view source print ?

01	public AbstractStringBuilder reverse() {

02	boolean hasSurrogate = false;

03	int n = count - 1;

04	for (int j = (n-1) >> 1; j >= 0; --j) {

05	char temp = value[j];

06	char temp2 = value[n - j];

07	if (!hasSurrogate) {

08	hasSurrogate = (temp >= Character.MIN_SURROGATE && temp <= Character.MAX_SURROGATE)

09	|| (temp2 >= Character.MIN_SURROGATE && temp2 <= Character.MAX_SURROGATE);

10

}

11	value[j] = temp2;

12	value[n - j] = temp;

13

}

14	if (hasSurrogate) {

15	// Reverse back all valid surrogate pairs

16	for (int i = 0; i < count - 1; i++) {

17	char c2 = value[i];

18	if (Character.isLowSurrogate(c2)) {

19	char c1 = value[i + 1];

20	if (Character.isHighSurrogate(c1)) {

21	value[i++] = c1;

22	value[i] = c2;

23

}

24

}

25

}

26

}

27	return this;

28

}

reverse分成两个部分：前面一个循环与后面的判断。

首先地一个循环很高效，循环次数为长度(count)的一半，而且使用>>位移运算，交换数组value[j]与value[n-j]的值。这里一是循环次数少，而是使用最高效的位移运算所以说这个reverse很高效。在反转过程中还完成了一件事：就是为hasSurrogate赋值。赋值的依据就是value[j]与value[n-j]两个字符时候有一个在\uD800和\uDFFF之间，如果有则赋值为true。

    
    public AbstractStringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }
    
    public AbstractStringBuilder append(String str) {
        //对于str==null的
        if (str == null) str = "null";
        int len = str.length();
        if (len == 0) return this;
        //新的字符串长度
        int newCount = count + len;
        if (newCount > value.length)
             //当新的字符串长度比原先数组长度大时，需要对char 数组扩容。
               expandCapacity(newCount);
        //将新添的数据追加到char类型数组中。
         str.getChars(0, len, value, count);
        count = newCount;
        return this;
    }
    
    //数组扩容 
    void expandCapacity(int minimumCapacity) {
        //先扩容成 (原先的长度+1）*2
        int newCapacity = (value.length + 1) * 2;
        //判断newCapacity值是否满足要求
         //如果新的长度还是不够，则直接取值 minimumCapacity 
        if (newCapacity < 0) {
           newCapacity = Integer.MAX_VALUE;
        } else if (minimumCapacity > newCapacity) {
           newCapacity = minimumCapacity;
        }	
        char newValue[] = new char[newCapacity];
        //将原先的数据拷贝到新的char 数组中。
         System.arraycopy(value, 0, newValue, 0, count);
        value = newValue;
    }

     public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > count) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, offset + srcBegin, dst, dstBegin,
             srcEnd - srcBegin);
    }