StringBuffer 和 StringBuilder

Search…
介绍
大多数情况下， StringBuffer 的速度要比 String 快； StringBuilder 要比StringBuffer快；StringBuffer 和 StringBuilder 都是 AbstractStringBuilder 的子类，区别在于StringBuffer 的方法大部分都有 synchronized 修饰。
源码解析
AbstractStringBuilder
变量及构造方法
1
/**
2
 * 用来存储字符的数组
3
 * The value is used for character storage.
4
 */
5
char[] value;
6
​
7
/**
8
 * 字符个数 
9
 * The count is the number of characters used.
10
 */
11
int count;
12
​
13
/**
14
 * This no-arg constructor is necessary for serialization of subclasses.
15
 */
16
AbstractStringBuilder() {
17
}
18
​
19
/**
20
 * 在构造方法中指定字符数组的长度
21
 * Creates an AbstractStringBuilder of the specified capacity.
22
 */
23
AbstractStringBuilder(int capacity) {
24
    value = new char[capacity];
25
}
Copied!
扩容
1
public void ensureCapacity(int minimumCapacity) {
2
    if (minimumCapacity > 0)
3
        ensureCapacityInternal(minimumCapacity);
4
}
5
​
6
private void ensureCapacityInternal(int minimumCapacity) {
7
    // overflow-conscious code
8
    if (minimumCapacity - value.length > 0) {
9
        value = Arrays.copyOf(value,
10
                newCapacity(minimumCapacity));
11
    }
12
}
13
​
14
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
15
​
16
private int newCapacity(int minCapacity) {
17
    // overflow-conscious code
18
    int newCapacity = (value.length << 1) + 2;
19
    if (newCapacity - minCapacity < 0) {
20
        newCapacity = minCapacity;
21
    }
22
    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
23
        ? hugeCapacity(minCapacity)
24
        : newCapacity;
25
}
26
​
27
private int hugeCapacity(int minCapacity) {
28
    if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
29
        throw new OutOfMemoryError();
30
    }
31
    return (minCapacity > MAX_ARRAY_SIZE)
32
        ? minCapacity : MAX_ARRAY_SIZE;
33
}
Copied!
扩容的方法最终由 newCapacity() 实现的，首先将容量左移一位（即扩大2倍）同时加2，如果此时任小于指定的容量，那么就将容量设置为 minimumCapacity 。然后判断是否溢出，通过 hugeCapacity 实现，如果溢出了（长度大于 Integer.MAX_VALUE ），则抛错（ OutOfMemoryError ）；否则根据 minCapacity 和 Integer.MAX_VALUE - 8 的大小比较确定数组容量为 max(minCapacity, Integer.MAX_VALUE - 8)。最后将 value 值进行拷贝，这一步显然是最耗时的操作。
append() 方法
1
public AbstractStringBuilder append(String str) {
2
    if (str == null)
3
        return appendNull();
4
    int len = str.length();
5
    ensureCapacityInternal(count + len);
6
    str.getChars(0, len, value, count);
7
    count += len;
8
    return this;
9
}
Copied!
append() 是最常用的方法，它有很多形式的重载。上面是最常用的一种，用于追加字符串。如果 str 是 null ，则直接调用 appendNull() 方法。这个方法就是直接追加 'n' 、 'u' 、'l'、'l' 这几个字符，方法如下：
1
private AbstractStringBuilder appendNull() {
2
    int c = count;
3
    ensureCapacityInternal(c + 4);
4
    final char[] value = this.value;
5
    value[c++] = 'n';
6
    value[c++] = 'u';
7
    value[c++] = 'l';
8
    value[c++] = 'l';
9
    count = c;
10
    return this;
11
}
Copied!
如果不是null，则首先需要判断数组容量是否足够，不够则需要扩容（扩容则是调用上述分析的扩容方法）； 然后调用 String 的 getChars() 方法将 str 追加到 value 末尾； 最后返回对象本身，所以 append() 可以连续调用(就是一种类似于链式编程)。
思考
为什么每次扩容是扩容为原来的两倍？
个人觉得是为了避免经常扩容带来的成本消耗。
为什么会加2呢？
个人也没想出什么好的解释，觉得可能是因为 Java 开发者认为我们在 append 数据的时候，中间经常会加一个分隔符，恰好这个分隔符在 Java 中正好占用两个字节。也不知道分析的对不对，有其他意见的大佬们可以在 issue​
中进行讨论。
StringBuilder 与 StringBuffer 方法对比
通过查看源码分析发现两者都继承至 AbstractStringBuilder 。 而 StringBuffer 之所以是线程安全的，是因为重写 AbstractStringBuilder 的方法的时候在前面加上了 synchronzied 修饰这些方法；而 StringBuilder 重写的时候只是直接调用父类的方法，没有做其他的操作。
其实通过阅读源码发现 StringBuilder 和 StringBuffer 之间的关系，类似于 HashMap 和 HashTable 之间的关系。
异常介绍
线程池
Last modified 2yr ago
Copy link
Contents
介绍
源码解析
AbstractStringBuilder
思考
StringBuilder 与 StringBuffer 方法对比