// 基于 JDK 25 (本地 JAVA_Source 仓), java.lang.AbstractStringBuilder —— 扩容与编码膨胀
private static boolean needsNewBuffer(byte[] value, byte coder, int newCapacity, byte newCoder) {
    long newLength = (long) newCapacity << newCoder;    // 用 long 算目标字节数, 防 int 溢出后误判"够用"
    return coder != newCoder || newLength > value.length || 0 > newLength;
}

// 需要换编码时走这条路: 扩容 + Latin1→UTF16 膨胀一次完成
private static byte[] ensureCapacityNewCoder(byte[] value, byte coder, int count,
                                             int minimumCapacity, byte newCoder) {
    assert coder == newCoder || newCoder == UTF16 : "bad new coder UTF16 -> LATIN1";    // 编码只升不降
    int oldCapacity = value.length >> coder;
    int growth = minimumCapacity - oldCapacity;
    int newCapacity = (growth <= 0)
            ? oldCapacity                       // 容量够就不动, 也绝不缩容
            : newCapacity(value, newCoder, minimumCapacity);
    assert count <= newCapacity : "count exceeds new capacity";

    if (coder == newCoder) {
        if (newCapacity > oldCapacity) {
            value = Arrays.copyOf(value, newCapacity << newCoder);
        }
        return value;
    } else {
        byte[] newValue = StringUTF16.newBytesFor(newCapacity);
        StringLatin1.inflate(value, 0, newValue, 0, count);     // 旧内容一字节膨胀成两字节, 顺手完成扩容
        return newValue;
    }
}

// 编码不变时的普通扩容(ensureCapacity 公开方法底下也是它)
private static byte[] ensureCapacitySameCoder(byte[] value, byte coder, int minimumCapacity) {
    int oldCapacity = value.length >> coder;
    if (minimumCapacity - oldCapacity > 0) {            // 减法比较而非 <, 溢出安全
        value = Arrays.copyOf(value,
                newCapacity(value, coder, minimumCapacity) << coder);
    }
    return value;
}

private static int newCapacity(byte[] value, byte coder, int minCapacity) {
    int oldLength = value.length;
    int newLength = minCapacity << coder;
    int growth = newLength - oldLength;
    int length = ArraysSupport.newLength(oldLength, growth, oldLength + (2 << coder));  // 首选增量 = 旧容量 + 2 字符, 即扩到 2 倍 + 2(不是 ArrayList 的 1.5 倍)
    if (length == Integer.MAX_VALUE) {
        throw new OutOfMemoryError("Required length exceeds implementation limit");
    }
    return length >> coder;
}

// 基于 JDK 25 (本地 JAVA_Source 仓), java.lang.StringBuilder
public final class StringBuilder
    extends AbstractStringBuilder
    implements Appendable, java.io.Serializable, Comparable<StringBuilder>, CharSequence
{
    // ... 省略 serialVersionUID

    @IntrinsicCandidate                 // JIT 特殊对待: 字符串拼接优化会识别并消除这些调用
    public StringBuilder() {
        super(16);                      // 默认 16 字符
    }

    @IntrinsicCandidate
    public StringBuilder(int capacity) {
        super(capacity);                // 能预估终态长度就用它一次给够, 全程零扩容零拷贝
    }

    // ... 省略几十个 append/insert 覆写: 内容全是 super.xxx(...) 后 return this,
    // 只为把返回类型从 AbstractStringBuilder 收窄成 StringBuilder, 保住链式调用

    @Override
    @IntrinsicCandidate
    public String toString() {
        if (length() == 0) {
            return "";                  // 空串走常量, 不分配
        }
        // Create a copy, don't share the array
        return new String(this, null);  // 必须拷贝: 共享数组的话后续 append 会改写已"生成"的 String
    }
}