C # o Java: ¿anteponer cadenas con StringBuilder?

Sé que podemos agregar cadenas usando StringBuilder. ¿Hay alguna forma en que podamos anteponer cadenas (es decir, agregar cadenas delante de una cadena) utilizando StringBuilderpara poder mantener los beneficios de rendimiento que StringBuilderofrece?

Usar el método de inserción con el parámetro de posición establecido en 0 sería lo mismo que anteponer (es decir, insertar al principio).

Un ejemplo es: varStringBuilder.insert(0, "someThing");

Funciona tanto para C # como para Java

Anteponer una cadena generalmente requerirá copiar todo después del punto de inserción de nuevo en la matriz de respaldo, por lo que no será tan rápido como agregar al final.

Pero puedes hacerlo así en Java (en C # es lo mismo, pero se llama al método Insert):

aStringBuilder.insert(0, "newText");

Si necesita un alto rendimiento con muchos prependidos, deberá escribir su propia versión de StringBuilder(o usar la de otra persona). Con el estándar StringBuilder(aunque técnicamente podría implementarse de manera diferente), la inserción requiere copiar los datos después del punto de inserción. Insertar n fragmentos de texto puede llevar O (n ^ 2) tiempo.

Un enfoque ingenuo sería agregar un desplazamiento en el char[]búfer de respaldo , así como la longitud. Cuando no haya suficiente espacio para un prefijo, suba los datos más de lo estrictamente necesario. Esto puede reducir el rendimiento a O (n log n) (creo). Un enfoque más refinado es hacer que el búfer sea cíclico. De esa manera, el espacio libre en ambos extremos de la matriz se vuelve contiguo.

Puedes probar un método de extensión:

/// <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!

Puede construir la cadena al revés y luego invertir el resultado. Usted incurre en un costo O (n) en lugar de un costo en el peor de los casos O (n ^ 2).

No lo he usado, pero Ropes For Java suena intrigante. El nombre del proyecto es un juego de palabras, use una cuerda en lugar de una cuerda para un trabajo serio. Evita la penalización de rendimiento por anteponer y otras operaciones. Vale la pena echarle un vistazo, si vas a hacer mucho de esto.

Una cuerda es un reemplazo de alto rendimiento para cuerdas. La estructura de datos, descrita en detalle en "Cuerdas: una alternativa a las cadenas", proporciona un rendimiento asintóticamente mejor que String y StringBuffer para modificaciones comunes de cadenas como anteponer, añadir, eliminar e insertar. Al igual que las cuerdas, las cuerdas son inmutables y, por lo tanto, son adecuadas para su uso en programación multiproceso.

Esto es lo que puede hacer si desea anteponer el uso de la clase StringBuilder de Java:

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

Si te entiendo correctamente, el método de inserción parece que hará lo que quieres. Simplemente inserte la cadena en el desplazamiento 0.

Intente usar Insertar ()

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

A juzgar por los otros comentarios, no existe una forma rápida estándar de hacer esto. Usar StringBuilder's .Insert(0, "text")es aproximadamente solo 1-3 veces más rápido que usar una concatenación de cadenas dolorosamente lenta (basada en> 10000 concats), por lo que a continuación se muestra una clase para anteponer potencialmente miles de veces más rápido.

He incluido alguna otra funcionalidad básica como append(), subString()y length()etc. Tanto los anexos como los antepuestos varían desde aproximadamente el doble de rápido hasta 3 veces más lento que los anexos de StringBuilder. Como StringBuilder, el búfer en esta clase aumentará automáticamente cuando el texto desborde el tamaño del búfer anterior.

El código se ha probado bastante, pero no puedo garantizar que esté libre de errores.

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)
    }
}

Puede crear una extensión para StringBuilder usted mismo con una clase simple:

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
    }
}

Luego, solo agrega:

using Application.Code.Helpers;

En la parte superior de cualquier clase en la que desee usar StringBuilder y cada vez que use intelli-sense con una variable StringBuilder, aparecerán los métodos Prepend y PrependLine. Solo recuerde que cuando use Anteponer, deberá anteponer en orden inverso que si estuviera anexando.

Esto debería funcionar:

aStringBuilder = "newText" + aStringBuilder;