为何StringBuilder的insert方法使用String.valueOf而非无垃圾实现？

Great question! You’ve spotted a notable inconsistency in how the JDK handles integer appends vs inserts in AbstractStringBuilder—and the short answer is yes, absolutely we can implement a garbage-free version of insert(int offset, int i). Let’s break this down:

Why the Current insert(int) Creates Garbage #

Right now, the insert(int offset, int i) method delegates to String.valueOf(i) first, which creates a new temporary String instance. That string’s underlying char[] is then copied into the AbstractStringBuilder’s internal array, and the temporary String becomes eligible for garbage collection. This contradicts the core goal of StringBuilder/StringBuffer to minimize unnecessary object allocations.

How to Build a Garbage-Free Insert #

We can mirror the approach used in append(int i) to avoid the temporary String. Here’s the step-by-step logic:

• Calculate the integer's string length: Use Integer.stringSize(i) (a package-private helper in Integer) to find how many characters the int will take when converted to a string—no object allocations needed here.
• Ensure sufficient capacity: Check if the internal char[] has enough space. If not, expand it using the existing ensureCapacityInternal method (just like the current insert implementation does).
• Shift existing characters: Use System.arraycopy to move all characters from the insertion offset onwards to the right by the integer’s string length. This makes room for the new characters without creating new objects.
• Write directly to the internal array: Call Integer.getChars(i, offset, value, this.value)—the same method used by append(int)—to write the integer’s character representation straight into the freed-up space in the internal char[].
• Update the length tracker: Adjust the count field (which tracks the builder’s current length) by adding the integer’s string length.

Example Implementation Snippet #

Here’s what this might look like in code, matching JDK conventions:

public AbstractStringBuilder insert(int offset, int i) {
    checkOffset(offset); // Reuse existing validation logic
    int len = Integer.stringSize(i);
    ensureCapacityInternal(count + len);
    System.arraycopy(value, offset, value, offset + len, count - offset);
    Integer.getChars(i, offset, value, this.value);
    count += len;
    return this;
}

Why Isn’t This in the JDK? #

It’s a fair follow-up! Possible reasons include:

• Historical legacy: The insert methods were implemented earlier, and the garbage-free append optimization was added later without updating all overloads.
• Maintenance overhead: AbstractStringBuilder has dozens of insert overloads for different types. Updating each to avoid temporary strings would require duplicating logic or building shared helpers, which might not have been a high priority.
• Negligible cost for small cases: For small integers, the temporary String allocation is so cheap that the JDK team might have focused optimization efforts on higher-impact areas.

Either way, the approach above is entirely valid and would eliminate the garbage allocation for integer inserts, aligning the behavior with the more efficient append(int) method.

内容的提问来源于stack exchange，提问作者Julius Häger