Question

我们知道StringBuffer的默认容量是16，当我们尝试添加第17个字符时，它将通过以下规则增加：

newCapacity =（当前容量+ 1）* 2;

StringBuffer sb = new StringBuffer();
sb.append("aaaaaaaaaaaaaaaa"); // length is 16
System.out.println(sb.capacity()); // it gives 16

如果我添加第17个字符

StringBuffer sb = new StringBuffer();
sb.append("aaaaaaaaaaaaaaaaa"); // length is 17
System.out.println(sb.capacity()); // it gives 34

但令人困惑的部分现在是

如果我尝试添加35个字符

StringBuffer sb = new StringBuffer();
sb.append("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); // length is 35
System.out.println(sb.capacity()); // it gives 35

此时的容量应该增加70.

有趣的部分是

StringBuffer sb = new StringBuffer();
sb.append("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); // length is 34
sb.append("a"); // added 35th char
System.out.println(sb.capacity()); // it gives 70  which is correct

任何人都可以对此有所了解吗？

Answer 1

expandCapacity中的StringBuffer确实：

int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
    newCapacity = minimumCapacity;

由于value.length示例中35当时为16，因此它将使用35（在minimumCapacity中给出）。但是，在最后一个示例中，在上一个append期间，value.length为34，minimumCapacity为35，因此新容量为value.length * 2 + 2。

Answer 2

具体细节可能略微取决于JDK版本，但取决于我的本地版本1.8.0_66：

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

private void ensureCapacityInternal(int minimumCapacity) {
    if (minimumCapacity - value.length > 0)
        expandCapacity(minimumCapacity);
}

void expandCapacity(int minimumCapacity) {
    int newCapacity = value.length * 2 + 2;
    if (newCapacity - minimumCapacity < 0)
        newCapacity = minimumCapacity;
    if (newCapacity < 0) {
        if (minimumCapacity < 0) // overflow
            throw new OutOfMemoryError();
        newCapacity = Integer.MAX_VALUE;
    }
    value = Arrays.copyOf(value, newCapacity);
}

请注意，value.length实际上是容量，而不是存储的字符串的长度。当前缓冲区中的字符数为count！还要记得value.length在调用new StringBuffer()时最初为16。考虑到这些因素，让我们为您呈现的每个案例进行一些堆栈跟踪。

对于大小为17的字符串：

sb.append("12345678901234567")  
    if (str == null) -> false
    len = 17;
    ensureCapacityInternal(0 + 17)
        if (17 - 16 > 0) -> true
            expandCapacity(17)
                newCapacity = 16 * 2 + 2 = 34
                if (34 - 17 < 0) -> false
                value = Arrays.copyOf("", 34)
    str.getChars(0, 17, "", 17)
    return this
sb.build() -> "12345678901234567"
sb.capacity() -> 34

对于大小为35的字符串：

sb.append("12345678901234567890123456789012345") 
    if (str == null) -> false
    len = 35;
    ensureCapacityInternal(0 + 35)
        if (35 - 16 > 0) -> true
            expandCapacity(35)
                newCapacity = 16 * 2 + 2 = 34
                if (34 - 35 < 0) -> true
                    newCapacity = 35
                value = Arrays.copyOf("", 35)
    str.getChars(0, 35, "", 35)
    return this
sb.build() -> "12345678901234567890123456789012345"
sb.capacity() -> 35

请注意，差异来自if (newCapacity - minimumCapacity < 0)行。如果附加的字符串长于oldCapacity * 2 + 2，则newCapacity将设置为要追加的字符串的长度。

换句话说，当附加时，如果缓冲区不足以容纳现有文本加上附加文本，它将检查（大致）加倍大小是否会保留新文本。如果仍然不够，而不是递归扩展，它将扩展到完全足够大。

这不仅发生在35，但是字符串比你的字符串长得多，你可能不会遇到你所附加的字符串是你当前容量的两倍多的情况。

如果你这样做，你也会看到相同的“长度=容量”，比如说

StringBuffer sBuffer = new StringBuffer();
sBuffer.append("1234567890123456");
System.out.println(sBuffer.capacity()); // 16
sBuffer.append("1234567890123456789"); 
System.out.println(sBuffer.capacity()); // 35

但不是

StringBuffer sBuffer = new StringBuffer();
sBuffer.append("1234567890123456");
System.out.println(sBuffer.capacity()); // 16
sBuffer.append("123456789012345678"); 
System.out.println(sBuffer.capacity()); // 34
sBuffer.append("1"); 
System.out.println(sBuffer.capacity()); // 70

StringBuffer的容量如何增加？

2 个答案: