How can we prepend strings with StringBuilder?

Prepending a String will usually require copying everything after the insertion point back some in the backing array, so it won't be as quick as appending to the end.

But you can do it like this in Java (in C# it's the same, but the method is called Insert):

aStringBuilder.insert(0, "newText");

If you require high performance with lots of prepends, you'll need to write your own version of StringBuilder (or use someone else's). With the standard StringBuilder (although technically it could be implemented differently) insert require copying data after the insertion point. Inserting n piece of text can take O(n^2) time.

A naive approach would be to add an offset into the backing char[] buffer as well as the length. When there is not enough room for a prepend, move the data up by more than is strictly necessary. This can bring performance back down to O(n log n) (I think). A more refined approach is to make the buffer cyclic. In that way the spare space at both ends of the array becomes contiguous.

Here's what you can do If you want to prepend using Java's StringBuilder class:

StringBuilder str = new StringBuilder();
str.Insert(0, "text");

You could try an extension method:

/// <summary>
/// kind of a dopey little one-off for StringBuffer, but 
/// an example where you can get crazy with extension methods
/// </summary>
public static void Prepend(this StringBuilder sb, string s)
{
    sb.Insert(0, s);
}

StringBuilder sb = new StringBuilder("World!");
sb.Prepend("Hello "); // Hello World!

You could build the string in reverse and then reverse the result. You incur an O(n) cost instead of an O(n^2) worst case cost.

If I understand you correctly, the insert method looks like it'll do what you want. Just insert the string at offset 0.

I haven't used it but Ropes For Java Sounds intriguing. The project name is a play on words, use a Rope instead of a String for serious work. Gets around the performance penalty for prepending and other operations. Worth a look, if you're going to be doing a lot of this.

A rope is a high performance replacement for Strings. The datastructure, described in detail in "Ropes: an Alternative to Strings", provides asymptotically better performance than both String and StringBuffer for common string modifications like prepend, append, delete, and insert. Like Strings, ropes are immutable and therefore well-suited for use in multi-threaded programming.

Try using Insert()

StringBuilder MyStringBuilder = new StringBuilder("World!");
MyStringBuilder.Insert(0,"Hello "); // Hello World!

Judging from the other comments, there's no standard quick way of doing this. Using StringBuilder's .Insert(0, "text") is approximately only 1-3x as fast as using painfully slow String concatenation (based on >10000 concats), so below is a class to prepend potentially thousands of times quicker!

I've included some other basic functionality such as append(), subString() and length() etc. Both appends and prepends vary from about twice as fast to 3x slower than StringBuilder appends. Like StringBuilder, the buffer in this class will automatically increase when the text overflows the old buffer size.

The code has been tested quite a lot, but I can't guarantee it's free of bugs.

class Prepender
{
    private char[] c;
    private int growMultiplier;
    public int bufferSize;      // Make public for bug testing
    public int left;            // Make public for bug testing
    public int right;           // Make public for bug testing
    public Prepender(int initialBuffer = 1000, int growMultiplier = 10)
    {
        c = new char[initialBuffer];
        //for (int n = 0; n < initialBuffer; n++) cc[n] = '.';  // For debugging purposes (used fixed width font for testing)
        left = initialBuffer / 2;
        right = initialBuffer / 2;
        bufferSize = initialBuffer;
        this.growMultiplier = growMultiplier;
    }
    public void clear()
    {
        left = bufferSize / 2;
        right = bufferSize / 2;
    }
    public int length()
    {
        return right - left;
    }

    private void increaseBuffer()
    {
        int nudge = -bufferSize / 2;
        bufferSize *= growMultiplier;
        nudge += bufferSize / 2;
        char[] tmp = new char[bufferSize];
        for (int n = left; n < right; n++) tmp[n + nudge] = c[n];
        left += nudge;
        right += nudge;
        c = new char[bufferSize];
        //for (int n = 0; n < buffer; n++) cc[n]='.';   // For debugging purposes (used fixed width font for testing)
        for (int n = left; n < right; n++) c[n] = tmp[n];
    }

    public void append(string s)
    {
        // If necessary, increase buffer size by growMultiplier
        while (right + s.Length > bufferSize) increaseBuffer();

        // Append user input to buffer
        int len = s.Length;
        for (int n = 0; n < len; n++)
        {
            c[right] = s[n];
            right++;
        }
    }
    public void prepend(string s)
    {
        // If necessary, increase buffer size by growMultiplier
        while (left - s.Length < 0) increaseBuffer();               

        // Prepend user input to buffer
        int len = s.Length - 1;
        for (int n = len; n > -1; n--)
        {
            left--;
            c[left] = s[n];
        }
    }
    public void truncate(int start, int finish)
    {
        if (start < 0) throw new Exception("Truncation error: Start < 0");
        if (left + finish > right) throw new Exception("Truncation error: Finish > string length");
        if (finish < start) throw new Exception("Truncation error: Finish < start");

        //MessageBox.Show(left + " " + right);

        right = left + finish;
        left = left + start;
    }
    public string subString(int start, int finish)
    {
        if (start < 0) throw new Exception("Substring error: Start < 0");
        if (left + finish > right) throw new Exception("Substring error: Finish > string length");
        if (finish < start) throw new Exception("Substring error: Finish < start");
        return toString(start,finish);
    }

    public override string ToString()
    {
        return new string(c, left, right - left);
        //return new string(cc, 0, buffer);     // For debugging purposes (used fixed width font for testing)
    }
    private string toString(int start, int finish)
    {
        return new string(c, left+start, finish-start );
        //return new string(cc, 0, buffer);     // For debugging purposes (used fixed width font for testing)
    }
}

You could create an extension for StringBuilder yourself with a simple class:

namespace Application.Code.Helpers
{
    public static class StringBuilderExtensions
    {
        #region Methods

        public static void Prepend(this StringBuilder sb, string value)
        {
            sb.Insert(0, value);
        }

        public static void PrependLine(this StringBuilder sb, string value)
        {
            sb.Insert(0, value + Environment.NewLine);
        }

        #endregion
    }
}

Then, just add:

using Application.Code.Helpers;

To the top of any class that you want to use the StringBuilder in and any time you use intelli-sense with a StringBuilder variable, the Prepend and PrependLine methods will show up. Just remember that when you use Prepend, you will need to Prepend in reverse order than if you were Appending.

This should work:

aStringBuilder = "newText" + aStringBuilder; 

I will prefer using char[] to store string and then convert to String/StringBuilder.

char[] is blazingly faster than String and StringBuilder.

package org.dakshay;
import java.util.Arrays;
public class Benchmark {


public static void main(String[] args) {
    int size = 1000000;
    benchmark_StringBuilder(size);
    benchmark_String(size);
    benchmark_Char_Array(size);
}

private static void benchmark_Char_Array(int size) {
    char[] arr = new char[size];
    Long before = System.currentTimeMillis();
    for(int i=0; i<size; i++){
        arr[i] = 'h';
    }
    String s = Arrays.toString(arr);
    System.out.println("Time Taken by Char Array in ms: " + (System.currentTimeMillis() - before));
}

private static void benchmark_String(int size) {
    String s = "";
    Long before = System.currentTimeMillis();
    for(int i=0; i<size; i++){
        s="h"+s;
    }
    System.out.println("Time Taken by String in ms: " + (System.currentTimeMillis() - before));

}

private static void benchmark_StringBuilder(int size) {
    StringBuilder sb = new StringBuilder();
    Long before = System.currentTimeMillis();
    for(int i=0; i<size; i++){
        sb.insert(0,"h");
    }
    System.out.println("Time Taken by StringBuilder in ms: " + (System.currentTimeMillis() - before));
}

}

Here I am prepending at 0th Index till 1M requests

From Benchmarking on JDK 22.0.2, RAM 16GB SSD 512 i5-12450H, below results are produced -

Time Taken by StringBuilder in ms: 10204
Time Taken by String in ms: 78268
Time Taken by Char Array in ms: 49

Char array produced faster index fill in 1M requests with 49 ms, followed by StringBuilder with 10 Sec, and then String with 78 Sec.