What is the difference between string
and StringBuilder
?
Also, what would be some examples for understanding?
This question is related to
c#
string
stringbuilder
A String (System.String) is a type defined inside the .NET framework. The String class is not mutable. This means that every time you do an action to an System.String instance, the .NET compiler create a new instance of the string. This operation is hidden to the developer.
A System.Text.StringBuilder is class that represents a mutable string. This class provides some useful methods that make the user able to manage the String wrapped by the StringBuilder. Notice that all the manipulations are made on the same StringBuilder instance.
Microsoft encourages the use of StringBuilder because it is more effective in terms of memory usage.
String
A String instance is immutable, that is, we cannot change it after it was created. If we perform any operation on a String it will return a new instance (creates a new instance in memory) instead of modifying the existing instance value.
StringBuilder
StringBuilder is mutable, that is, if we perform any operation on StringBuilder it will update the existing instance value and it will not create new instance.
A String is an immutable type. This means that whenever you start concatenating strings with each other you're creating new strings each time. If you do so many times you end up with a lot of heap overhead and the risk of running out of memory.
A StringBuilder instance is used to be able to append strings to the same instance, creating a string when you call the ToString method on it.
Due to the overhead of instantiating a StringBuilder object it's said by Microsoft that it's useful to use when you have more than 5-10 string concatenations.
For sample code I suggest you take a look here:
A StringBuilder will help you when you need to build strings in multiple steps.
Instead of doing this:
String x = "";
x += "first ";
x += "second ";
x += "third ";
you do
StringBuilder sb = new StringBuilder("");
sb.Append("first ");
sb.Append("second ");
sb.Append("third");
String x = sb.ToString();
The final effect is the same, but the StringBuilder will use less memory and will run faster. Instead of creating a new string which is the concatenation of the two, it will create the chunks separately, and only at the end it will unite them.
Major difference:
String is immutable. It means that you can't modify a string at all; the result of modification is a new string. This is not effective if you plan to append to a string.
StringBuilder is mutable. It can be modified in any way and it doesn't require creation of a new instance. When the work is done, ToString() can be called to get the string.
Strings can participate in interning. It means that strings with same contents may have same addresses. StringBuilder can't be interned.
String is the only class that can have a reference literal.
String
Under System namespace
Immutable (readonly) instance
Performance degrades when continuous change of value occurs
Thread-safe
StringBuilder (mutable string)
For a descriptive article about this topic with a lot of examples using ObjectIDGenerator, follow this link.
Related Stack Overflow question: Mutability of string when string doesn't change in C#
From the StringBuilder Class documentation:
The String object is immutable. Every time you use one of the methods in the System.String class, you create a new string object in memory, which requires a new allocation of space for that new object. In situations where you need to perform repeated modifications to a string, the overhead associated with creating a new String object can be costly. The System.Text.StringBuilder class can be used when you want to modify a string without creating a new object. For example, using the StringBuilder class can boost performance when concatenating many strings together in a loop.
Strings are immutable i.e if you change their value, the old value will be discarded and a new value is created on the heap, whereas in string builder we can modify the existing value without the new value being created.
So performance-wise String Builder is beneficial as we are needlessly not occupying more memory space.
String is immutable, which means that when you create a string you can never change it. Rather it will create a new string to store the new value, and this can be inefficient if you need to change the value of a string variable a lot.
StringBuilder can be used to simulate a mutable string, so it is good for when you need to change a string a lot.
System.String is a mutable object, meaning it cannot be modified after it’s been created. Please refer to Difference between string and StringBuilder in C#? for better understanding.
Also the complexity of concatenations of String is O(N2), while for StringBuffer it is O(N).
So there might be performance problem where we use concatenations in loops as a lot of new objects are created each time.
You can use the Clone
method if you want to iterate through strings along with the string builder... It returns an object so you can convert to a string using the ToString method...:)
Source: Stackoverflow.com