it-swarm-ru.tech

String vs. StringBuilder

Я понимаю разницу между String и StringBuilder (StringBuilder является изменяемой), но есть ли большая разница в производительности между ними?

В программе, над которой я работаю, добавлено много строк (500+). Является ли использование StringBuilder лучшим выбором?

202
Kuvo

Да, разница в производительности значительна. См. Статью базы знаний " Как улучшить производительность конкатенации строк в Visual C # ".

Я всегда пытался сначала написать код для ясности, а потом оптимизировать для повышения производительности. Это намного проще, чем делать это наоборот! Однако, увидев огромную разницу в производительности в моих приложениях между этими двумя, я теперь думаю об этом немного более тщательно.

К счастью, довольно просто выполнить анализ производительности вашего кода, чтобы увидеть, на что вы тратите время, а затем изменить его, чтобы использовать StringBuilder, где это необходимо.

224
Jay Bazuzi

Чтобы уточнить, что сказала Джиллиан о 4-й строке, если у вас есть что-то вроде этого:

string a,b,c,d;
 a = b + c + d;

тогда было бы быстрее использовать строки и оператор плюс. Это потому, что (как и Java, как указывает Эрик), он автоматически использует StringBuilder (на самом деле, он использует примитив, который также использует StringBuilder)

Однако, если то, что вы делаете, ближе к:

string a,b,c,d;
 a = a + b;
 a = a + c;
 a = a + d;

Тогда вам нужно явно использовать StringBuilder. .Net здесь не создает автоматически StringBuilder, потому что это было бы бессмысленно. В конце каждой строки "a" должна быть (неизменяемой) строкой, поэтому она должна создавать и размещать StringBuilder в каждой строке. Для скорости вам нужно будет использовать тот же StringBuilder, пока вы не закончите сборку:

string a,b,c,d;
StringBuilder e = new StringBuilder();
 e.Append(b);
 e.Append(c);
 e.Append(d);
 a = e.ToString();
54
James Curran

StringBuilder предпочтительнее ЕСЛИ вы делаете несколько циклов или разветвлений в проходе кода ... однако, для производительности PURE, если вы можете обойтись с SINGLE = объявление строки, тогда это гораздо более производительно.

Например:

string myString = "Some stuff" + var1 + " more stuff"
                  + var2 + " other stuff" .... etc... etc...;

более производительный, чем

StringBuilder sb = new StringBuilder();
sb.Append("Some Stuff");
sb.Append(var1);
sb.Append(" more stuff");
sb.Append(var2);
sb.Append("other stuff");
// etc.. etc.. etc..

В этом случае StringBuild можно считать более поддерживаемым, но не более производительным, чем однострочное объявление.

9 раз из 10, хотя ... используйте строителя строк.

С другой стороны: строка + var также более производительна, чем подход string.Format (обычно), который использует StringBuilder для внутреннего использования (если есть сомнения ... проверьте отражатель!)

28
calebjenkins

Этот тест показывает, что обычная конкатенация быстрее при объединении 3 или менее строк.

http://www.chinhdo.com/20070224/stringbuilder-is-not-always-faster/

StringBuilder может значительно улучшить использование памяти, особенно в случае добавления 500 строк вместе.

Рассмотрим следующий пример:

string buffer = "The numbers are: ";
for( int i = 0; i < 5; i++)
{
    buffer += i.ToString();
}
return buffer;

Что происходит в памяти? Создаются следующие строки:

1 - "The numbers are: "
2 - "0"
3 - "The numbers are: 0"
4 - "1"
5 - "The numbers are: 01"
6 - "2"
7 - "The numbers are: 012"
8 - "3"
9 - "The numbers are: 0123"
10 - "4"
11 - "The numbers are: 01234"
12 - "5"
13 - "The numbers are: 012345"

Добавив эти пять чисел в конец строки, мы создали 13 строковых объектов! И 12 из них были бесполезны! Вот Это Да!

StringBuilder решает эту проблему. Это не "изменяемая строка", как мы часто слышим ( все строки в .NET являются неизменяемыми ). Он работает, сохраняя внутренний буфер, массив char. Вызов Append () или AppendLine () добавляет строку в пустое пространство в конце массива char; если массив слишком мал, он создает новый, больший массив и копирует туда буфер. Таким образом, в приведенном выше примере StringBuilder может потребоваться только один массив, содержащий все 5 дополнений к строке - в зависимости от размера его буфера. Вы можете указать StringBuilder, насколько большим должен быть его буфер в конструкторе.

23
Matt Trunnell

Простой пример, демонстрирующий разницу в скорости при использовании конкатенации String vs StringBuilder:

System.Diagnostics.Stopwatch time = new Stopwatch();
string test = string.Empty;
time.Start();
for (int i = 0; i < 100000; i++)
{
    test += i;
}
time.Stop();
System.Console.WriteLine("Using String concatenation: " + time.ElapsedMilliseconds + " milliseconds");

Результат:

Использование конкатенации строк: 15423 миллисекунд

StringBuilder test1 = new StringBuilder();
time.Reset();
time.Start();
for (int i = 0; i < 100000; i++)
{
    test1.Append(i);
}
time.Stop();
System.Console.WriteLine("Using StringBuilder: " + time.ElapsedMilliseconds + " milliseconds");

Результат:

Использование StringBuilder: 10 миллисекунд

В результате первая итерация заняла 15423 мс, а вторая итерация с использованием StringBuilder заняла 10 мс.

Мне кажется, что использование StringBuilder быстрее, намного быстрее.

19
Diizzy

Да, StringBuilder дает лучшую производительность при выполнении повторной операции над строкой. Это происходит потому, что все изменения вносятся в один экземпляр, поэтому он может сэкономить много времени вместо создания нового экземпляра, такого как String.

String Vs Stringbuilder

  • String

    1. в пространстве имен System
    2. неизменяемый (только для чтения) экземпляр
    3. производительность падает, когда происходит постоянное изменение значения
    4. потокобезопасный
  • StringBuilder (изменяемая строка)

    1. в пространстве имен System.Text
    2. изменчивый экземпляр
    3. показывает лучшую производительность, поскольку в существующий экземпляр вносятся новые изменения

Настоятельно рекомендуем статью о дотнет-мобе: String Vs StringBuilder в C # .

Связанный вопрос переполнения стека: Изменчивость строки, когда строка не изменяется в C #? .

11
Shamseer K

StringBuilder уменьшает количество выделений и назначений за счет использования дополнительной памяти. При правильном использовании он может полностью избавить компилятор от необходимости снова и снова выделять все большие и большие строки, пока не будет найден результат.

string result = "";
for(int i = 0; i != N; ++i)
{
   result = result + i.ToString();   // allocates a new string, then assigns it to result, which gets repeated N times
}

vs.

String result;
StringBuilder sb = new StringBuilder(10000);   // create a buffer of 10k
for(int i = 0; i != N; ++i)
{
   sb.Append(i.ToString());          // fill the buffer, resizing if it overflows the buffer
}

result = sb.ToString();   // assigns once
8
moswald

String Vs String Builder:

Прежде всего вы должны знать, в каком собрании живут эти два класса?

Так,

строка присутствует в пространстве имен System.

а также

StringBuilder присутствует в пространстве имен System.Text.

Для строкового объявления:

Вы должны включить пространство имен System. что-то вроде этого. Using System;

а также

Для объявления StringBuilder :

Вы должны включить пространство имен System.text. что-то вроде этого. Using System.text;

Приходите на актуальный вопрос.

В чем разница между строкой и StringBuilder ?

Основное различие между этими двумя заключается в том, что:

строка является неизменной.

а также

StringBuilder является изменяемым.

Итак, теперь давайте обсудим разницу между неизменяемым и изменяемым

Изменяемый: : означает изменяемый.

Неизменный: : означает Не изменяемый.

Например:

using System;

namespace StringVsStrigBuilder
{
    class Program
    {
        static void Main(string[] args)
        {
            // String Example

            string name = "Rehan";
            name = name + "Shah";
            name = name + "RS";
            name = name + "---";
            name = name + "I love to write programs.";

            // Now when I run this program this output will be look like this.
            // output : "Rehan Shah RS --- I love to write programs."
        }
    }
}

Так что в этом случае мы собираемся менять один и тот же объект 5 раз.

Таким образом, очевидный вопрос заключается в том! Что на самом деле происходит под капотом, когда мы меняем одну и ту же струну 5 раз.

Это то, что происходит, когда мы меняем одну и ту же строку 5 раз.

давай посмотрим на фигуру.

enter image description here

Explaination:

Когда мы впервые инициализируем эту переменную "name" как "Rehan", i-e string name = "Rehan", эта переменная создается в стеке "name" и указывает на это значение "Rehan". после выполнения этой строки: "name = name +" Shah ". Переменная-ссылка больше не указывает на этот объект" Rehan ", теперь она указывает на" Shah "и так далее.

Таким образом, string является неизменным, что означает, что как только мы создадим объект в памяти, мы не сможем его изменить.

Поэтому, когда мы объединяем переменную name, предыдущий объект остается там в памяти, и создается другой новый строковый объект ...

Итак, из приведенного выше рисунка у нас есть пять объектов, четыре объекта выброшены, они вообще не используются. Они все еще остаются в памяти, и они занимают объем памяти. "Сборщик мусора" отвечает за то, что так убирает ресурсы из памяти.

Так что в случае строки в любое время, когда мы манипулируем строкой снова и снова, у нас есть много объектов, созданных и находящихся там в памяти.

Так что это история строковой переменной.

Теперь давайте посмотрим на объект StringBuilder. Например:

using System;
using System.Text;

namespace StringVsStrigBuilder
{
    class Program
    {
        static void Main(string[] args)
        {
            // StringBuilder Example

            StringBuilder name = new StringBuilder();
            name.Append("Rehan");
            name.Append("Shah");
            name.Append("RS");
            name.Append("---");
            name.Append("I love to write programs.");


            // Now when I run this program this output will be look like this.
            // output : "Rehan Shah Rs --- I love to write programs."
        }
    }
}

Так что в этом случае мы собираемся менять один и тот же объект 5 раз.

Таким образом, очевидный вопрос заключается в том! Что на самом деле происходит под капотом, когда мы меняем один и тот же StringBuilder 5 раз.

Вот что происходит, когда мы меняем один и тот же StringBuilder 5 раз.

давай посмотрим на фигуру. enter image description here

Объяснение: В случае объекта StringBuilder. Вы не получите новый объект. Тот же объект будет изменен в памяти, поэтому даже если вы измените объект и, скажем, 10 000 раз, у нас останется только один объект stringBuilder.

У вас нет много мусорных объектов или объектов без_объектов stringBuilder, потому что это может быть изменено. Это изменчивое значение, что оно меняется со временем?

Отличия:

  • String присутствует в пространстве имен System, а Stringbuilder присутствует в пространстве имен System.Text.
  • строка является неизменной, где StringBuilder является мутабом.
4
Rehan Shah

Производительность операции конкатенации для объекта String или StringBuilder зависит от того, как часто происходит выделение памяти. Операция конкатенации String всегда выделяет память, тогда как операция конкатенации StringBuilder выделяет память, только если буфер объекта StringBuilder слишком мал для размещения новых данных. Следовательно, класс String предпочтителен для операции конкатенации, если конкатенируется фиксированное количество объектов String. В этом случае отдельные операции конкатенации могут даже объединяться в одну операцию компилятором. Объект StringBuilder предпочтителен для операции конкатенации, если конкатенируется произвольное количество строк; например, если цикл объединяет случайное количество строк пользовательского ввода.

Источник: MSDN

4
user487069

StringBuilder лучше для построения строки из множества непостоянных значений.

Если вы строите строку из большого количества константных значений, таких как несколько строк значений в документе HTML или XML или других кусках текста, вы можете просто добавить одну и ту же строку, потому что почти все компиляторы делают "постоянное сворачивание" - процесс сокращения дерева разбора, когда у вас есть куча постоянных манипуляций (он также используется, когда вы пишете что-то вроде int minutesPerYear = 24 * 365 * 60). А для простых случаев с непостоянными значениями, добавляемыми друг к другу, компилятор .NET уменьшит ваш код до чего-то похожего на то, что делает StringBuilder.

Но когда ваше приложение не может быть уменьшено компилятором до чего-то более простого, вам понадобится StringBuilder. Как указывает fizch, это чаще всего происходит внутри цикла.

3
JasonTrue
2
Jim G.

Использование строк для объединения может привести к усложнению во время выполнения порядка O(n^2).

Если вы используете StringBuilder, копирование памяти требует гораздо меньше усилий. С StringBuilder(int capacity) вы можете повысить производительность, если сможете оценить, насколько большим будет итоговое String. Даже если вы не точны, вам, вероятно, придется увеличить емкость StringBuilder только пару раз, что также может повысить производительность.

2
Steve g

Я видел значительный прирост производительности при использовании вызова метода EnsureCapacity(int capacity) для экземпляра StringBuilder перед его использованием для любого хранения строк. Я обычно называю это в строке кода после создания экземпляра. Это имеет тот же эффект, как если бы вы создали экземпляр StringBuilder следующим образом:

var sb = new StringBuilder(int capacity);

Этот вызов заблаговременно выделяет необходимую память, что приводит к меньшему выделению памяти во время нескольких операций Append(). Вы должны сделать обоснованное предположение о том, сколько памяти вам понадобится, но для большинства приложений это не должно быть слишком сложным. Я обычно ошибаюсь на стороне слишком большого количества памяти (мы говорим 1k или около того).

2
Jason Jackson

Я считаю, что StringBuilder быстрее, если у вас есть более 4 строк, которые нужно добавить вместе. Плюс он может делать некоторые классные вещи, такие как AppendLine.

2
Gilligan

В .NET StringBuilder все еще быстрее, чем добавление строк. Я почти уверен, что в Java они просто создают StringBuffer под капотом, когда вы добавляете строки, так что на самом деле нет никакой разницы. Я не уверен, почему они еще не сделали этого в .NET.

2
Eric Z Beard

String и StringBuilder на самом деле являются неизменными, StringBuilder имеет встроенные буферы, которые позволяют более эффективно управлять его размером. Когда StringBuilder необходимо изменить размер, это когда он перераспределяется в куче. По умолчанию он имеет размер до 16 символов, вы можете установить это в конструкторе.

например.

StringBuilder sb = new StringBuilder (50);

1
capgpilk

В дополнение к предыдущим ответам, первое, что я всегда делаю, когда думаю о таких проблемах, - это создаю небольшое тестовое приложение. Внутри этого приложения проведите некоторый временной тест для обоих сценариев и убедитесь сами, что быстрее.

ИМХО, при добавлении более 500 строковых записей обязательно следует использовать StringBuilder.

1
RichS

Конкатенация строк обойдется вам дороже. В Java вы можете использовать либо StringBuffer, либо StringBuilder в зависимости от ваших потребностей. Если вы хотите синхронизированную и поточно-ориентированную реализацию, перейдите к StringBuffer. Это будет быстрее, чем конкатенация строк.

Если вам не нужна синхронизированная или поточно-ориентированная реализация, перейдите на StringBuilder. Это будет быстрее, чем конкатенация строк, а также быстрее, чем StringBuffer, так как они не требуют дополнительной синхронизации.

1
raffimd

StringBuilder значительно более эффективен, но вы не увидите эту производительность, если не будете выполнять большое количество модификаций строк.

Ниже приведен небольшой фрагмент кода, чтобы привести пример производительности. Как вы можете видеть, вы действительно начинаете видеть значительное увеличение производительности, когда начинаете большие итерации.

Как вы можете видеть, 200 000 итераций заняли 22 секунды, в то время как 1 миллион итераций с использованием StringBuilder был почти мгновенным.

string s = string.Empty;
StringBuilder sb = new StringBuilder();

Console.WriteLine("Beginning String + at " + DateTime.Now.ToString());

for (int i = 0; i <= 50000; i++)
{
    s = s + 'A';
}

Console.WriteLine("Finished String + at " + DateTime.Now.ToString());
Console.WriteLine();

Console.WriteLine("Beginning String + at " + DateTime.Now.ToString());

for (int i = 0; i <= 200000; i++)
{
    s = s + 'A';
}

Console.WriteLine("Finished String + at " + DateTime.Now.ToString());
Console.WriteLine();
Console.WriteLine("Beginning Sb append at " + DateTime.Now.ToString());

for (int i = 0; i <= 1000000; i++)
{
    sb.Append("A");
}
Console.WriteLine("Finished Sb append at " + DateTime.Now.ToString());

Console.ReadLine();

Результат приведенного выше кода:

Начало строки + 28.01.2013 16:55:40.

Готовая строка + на 28.01.2013 16:55:40.

Начало строки + 28.01.2013 16:55:40.

Готовая строка + на 28.01.2013 16:56:02.

Начало Sb append 28.01.2013 16:56:02.

Закончено добавление Сб в 28.01.2013 16:56:02.

0
CathalMF

Как общее практическое правило, если мне нужно установить значение строки более одного раза, или если есть какие-либо добавления к строке, то он должен быть строителем строки. Я видел приложения, которые я написал в прошлом, прежде чем узнал о строителях строк, у которых был огромный отпечаток памяти, который, кажется, продолжает расти и расти. Изменение этих программ для использования строителя строк значительно сокращает использование памяти. Теперь я клянусь строителем строк.

0
user13288

Мой подход всегда заключался в использовании StringBuilder при конкатенации 4 или более строк OR Когда я не знаю, как могут происходить конкатенации.

Хорошая статья о производительности здесь

0
JohnC

StringBuilder, вероятно, предпочтительнее. Причина в том, что он выделяет больше места, чем требуется в настоящее время (вы устанавливаете количество символов), чтобы оставить место для будущих добавлений. Тогда те будущие добавления, которые помещаются в текущий буфер, не требуют выделения памяти или сборки мусора, что может быть дорогостоящим. В общем, я использую StringBuilder для сложной конкатенации строк или многократного форматирования, затем преобразовываю в обычную строку, когда данные полны, и я снова хочу неизменный объект.

0
deemer

Если вы делаете много конкатенации строк, используйте StringBuilder. Когда вы объединяете строку, вы каждый раз создаете новую строку, используя больше памяти.

Alex

0
Alex Fort