Schnellste Methode zum entfernen von chars aus dem string

Ich habe einen string, aus dem ich zu entfernen folgenden char: '\r', '\n' und '\t'.
Ich habe versucht, drei verschiedene Wege, um diese zu entfernen char und getestet Sie, so kann ich Holen Sie sich die Schnellste Lösung.

Folgenden sind die Methoden und es Ausführungszeit, wenn ich lief Sie 1000000 mal:

Sollte es werden Schnellste Lösung, wenn ich 1 oder 2 char zu entfernen. Aber als ich in char mehr, es beginnt zu mehr Zeit in Anspruch nehmen

str = str.Replace("\r", string.Empty).Replace("\n", string.Empty).Replace("\t", string.Empty);

Ausführungszeit = 1695

Für 1 oder 2 char, das war langsamer als String.Ersetzen, aber für 3 char es zeigte sich eine bessere Leistung.

string[] split = str.Split(new char[] { '\t', '\r', '\n' }, StringSplitOptions.None);
str = split.Aggregate<string>((str1, str2) => str1 + str2);

Ausführungszeit = 1030

Die langsamste von allen, sogar mit 1 char. Vielleicht ist mein regulärer Ausdruck nicht der beste ist.

str = Regex.Replace(str, "[\r\n\t]", string.Empty, RegexOptions.Compiled);

Execution time = 3500

Dies sind die drei Lösungen, die ich kam mit. Gibt es eine bessere und schnellere Lösung, dass hier jemand weiß, oder irgendwelche Verbesserungen kann ich in diesem code?

String, dass ich für benchmarking:

StringBuilder builder = new StringBuilder();
        builder.AppendFormat("{0}\r\n{1}\t\t\t\r\n{2}\t\r\n{3}\r\n{4}\t\t\r\n{5}\r\n{6}\r\n{7}\r\n{8}\r\n{9}",
         "SELECT ",
         "[Extent1].[CustomerID] AS [CustomerID], ",
         "[Extent1].[NameStyle] AS [NameStyle], ",
         "[Extent1].[Title] AS [Title], ",
           "[Extent1].[FirstName] AS [FirstName], ",
           "[Extent1].[MiddleName] AS [MiddleName], ",
           "[Extent1].[LastName] AS [LastName], ",
           "[Extent1].[Suffix] AS [Suffix], ",
           "[Extent1].[CompanyName] AS [CompanyName], ",
           "[Extent1].[SalesPerson] AS [SalesPerson], ");
        string str = builder.ToString();
InformationsquelleAutor ata | 2010-02-02
  1. 17

    Hier ist die uber-schnell unsichere version, version 2.

        public static unsafe string StripTabsAndNewlines(string s)
    {
        int len = s.Length;
        char* newChars = stackalloc char[len];
        char* currentChar = newChars;

        for (int i = 0; i < len; ++i)
        {
            char c = s[i];
            switch (c)
            {
                case '\r':
                case '\n':
                case '\t':
                    continue;
                default:
                    *currentChar++ = c;
                    break;
            }
        }
        return new string(newChars, 0, (int)(currentChar - newChars));
    }

    Und hier sind die benchmarks (time to strip 1000000 strings in ms)

     cornerback84 String.Ersetzen: 9433 
Andy West ' s String.Concat: 4756 
AviJ ' s char-array: 1374 
Matt Howells' char-Zeiger: 1163
    • Ja, es ist. Ausführungszeit = 195
    • btw, du brauchst eine neue Maschine 😛
    • Es ist eine aktuelle Xeon - wahrscheinlich unsere benchmarks sind nur anders gesetzt.
    InformationsquelleAutor Matt Howells
  2. 9

    Ich glaube, Sie bekommen die bestmögliche Leistung durch das zusammensetzen von den neuen string als char-array und nur diese in einen string umwandeln, wenn Sie fertig sind, in etwa so:

    string s = "abc";
int len = s.Length;
char[] s2 = new char[len];
int i2 = 0;
for (int i = 0; i < len; i++)
{
    char c = s[i];
    if (c != '\r' && c != '\n' && c != '\t')
        s2[i2++] = c;
}
return new String(s2, 0, i2);

    EDIT: Zeichenfolge verwenden(s2, 0, i2) statt Trim(), pro Vorschlag

    • Eine Korrektur, Sie haben zu tun return new String(s2).TrimEnd('\0'); Und die Ausführungszeit = 309. Große
    • Infact ich machte eine kleine änderung. Sie sind bereits halten Sie die Länge des neuen Arrays, d.h. i2. Also dann lieber trimmen, können Sie mit return new String(s2, 0, i2); Das bringt die Ausführungszeit 255
    InformationsquelleAutor AviJ
  3. 4
    String.Join(null, str.Split(new char[] { '\t', '\r', '\n' },
    StringSplitOptions.None));

    könnte Ihnen eine performance-Steigerung gegenüber der Verwendung Aggregate() seit Join() ist speziell für strings.

    BEARBEITEN:

    Tatsächlich, das könnte noch besser sein:

    String.Concat(str.Split(new char[] { '\t', '\r', '\n' },
    StringSplitOptions.None));
    • Ausführungszeit = 754. Dank
    • Schön! Ich aktualisiert meine Antwort zu verwenden Concat() statt. Könnte einen Versuch Wert sein.
    • Es war eine leichte Verbesserung bei der Verwendung von String.Concat. Nun, Ausführungszeit = 734
    InformationsquelleAutor Andy West
  4. 2

    Durchlaufen der Schnur und mit (nur einer) StringBuilder (mit dem richtigen argument im Konstruktor, um zu vermeiden, unnötige Speicher-Allokationen), um erstellen Sie eine neue Zeichenfolge, die schneller sein könnte.

    InformationsquelleAutor
  5. 2

    Sogar noch schneller:

    public static string RemoveMultipleWhiteSpaces(string s)
    {
        char[] sResultChars = new char[s.Length];

        bool isWhiteSpace = false;
        int sResultCharsIndex = 0;

        for (int i = 0; i < s.Length; i++)
        {
            if (s[i] == ' ')
            {
                if (!isWhiteSpace)
                {
                    sResultChars[sResultCharsIndex] = s[i];
                    sResultCharsIndex++;
                    isWhiteSpace = true;
                }
            }
            else
            {
                sResultChars[sResultCharsIndex] = s[i];
                sResultCharsIndex++;
                isWhiteSpace = false;
            }
        }

        return new string(sResultChars, 0, sResultCharsIndex);
    }
    InformationsquelleAutor Kostjagarnix
  6. 1

    versuchen, diese

    string str = "something \tis \nbetter than nothing";
string removeChars = new String(new Char[]{'\n', '\t'});
string newStr = new string(str.ToCharArray().Where(c => !removeChars.Contains(c)).ToArray());
    • Ausführungszeit = 27020.
    InformationsquelleAutor Faisal
  7. 0
    string str;
str = str.Replace(Environment.NewLine, string.Empty).Replace("\t", string.Empty);
    • Dies ist nichts anderes als die LANGSAME version in der akzeptierten Antwort. Die OP ist zu Fragen, für die schnellsten.
    InformationsquelleAutor Chethan
Schreibe einen Kommentar