What is the main difference between `StringBuffer` and `StringBuilder`?
Is there any performance issues when deciding on any one of these?

Difference between StringBuilder and StringBuffer

Given the 2 `toString()` implementations below, which one is preferred:

    public String toString(){
        return &quot;{a:&quot;+ a + &quot;, b:&quot; + b + &quot;, c: &quot; + c +&quot;}&quot;;
    }
or

    public String toString(){
        StringBuilder sb = new StringBuilder(100);
        return sb.append(&quot;{a:&quot;).append(a)
              .append(&quot;, b:&quot;).append(b)
              .append(&quot;, c:&quot;).append(c)
              .append(&quot;}&quot;)
              .toString();
    }
?

More importantly, given we have only 3 properties it might not make a difference, but at what point would you switch from `+` concat to  `StringBuilder`?

StringBuilder vs String concatenation in toString() in Java

I&#39;m using a [StringBuilder][1] in a loop and every x iterations I want to empty it and start with an empty `StringBuilder`, but I can&#39;t see any method similar to the .NET [StringBuilder.Clear][2] in the documentation, just the [delete][3] method which seems overly complicated.

So what is the best way to clean out a `StringBuilder` in Java?

  [1]: http://download.oracle.com/javase/1.5.0/docs/api/java/lang/StringBuilder.html
  [2]: http://msdn.microsoft.com/en-us/library/system.text.stringbuilder.clear.aspx
  [3]: http://download.oracle.com/javase/1.5.0/docs/api/java/lang/StringBuilder.html#delete%28int,%20int%29


How can I clear or empty a StringBuilder?

When you have to loop through a collection and make a string of each data separated by a delimiter, you always end up with an extra delimiter at the end, e.g.

    for (String serverId : serverIds) {
      sb.append(serverId);
       sb.append(&quot;,&quot;);
    }

Gives something like : **serverId_1, serverId_2, serverId_3,**

I would like to delete the last character in the StringBuilder (without converting it because I still need it after this loop).

Remove last character of a StringBuilder?

I have a [`StringBuilder`][1] object,

    StringBuilder result = new StringBuilder();
    result.append(someChar);

Now I want to append a newline character to the `StringBuilder`. How can I do it?

    result.append(&quot;/n&quot;); 

Does not work. So, I was thinking about writing a newline using Unicode. Will this help? If so, how can I add one?

  [1]: http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html

How to append a newline to StringBuilder

I see [a few code project solutions][1].

But is there a regular implementation in JavaScript?


  [1]: http://www.codeproject.com/KB/scripting/stringbuilder.aspx 

Does JavaScript have a built in stringbuilder class?

Please tell me a real time situation to compare `String`, `StringBuffer`, and `StringBuilder`?

String, StringBuffer, and StringBuilder

Suppose I have a stringbuilder in C# that does this:

    StringBuilder sb = new StringBuilder();
    string cat = &quot;cat&quot;;
    sb.Append(&quot;the &quot;).Append(cat).(&quot; in the hat&quot;);
    string s = sb.ToString();

would that be as efficient or any more efficient as having:

    string cat = &quot;cat&quot;;
    string s = String.Format(&quot;The {0} in the hat&quot;, cat);

If so, why?

**EDIT** 

After some interesting answers, I realised I probably should have been a little clearer in what I was asking. I wasn&#39;t so much asking for which was quicker at concatenating a string, but which is quicker at **_injecting_** one string into another.

In both cases above I want to inject one or more strings into the middle of a predefined template string.

Sorry for the confusion

Is String.Format as efficient as StringBuilder

I know we can append strings using `StringBuilder`. Is there a way we can prepend strings (i.e. add strings in front of a string) using `StringBuilder` so we can keep the performance benefits that `StringBuilder` offers?

How can we prepend strings with StringBuilder?

I have the following 
    
    data.AppendFormat(&quot;{0},&quot;,dataToAppend);

The problem with this is that I am using it in a loop and there will be a trailing comma. What is the best way to remove the trailing comma?

Do I have to change data to a string and then substring it?

Best way to remove the last character from a string built with stringbuilder

I could only do this with String, for example: 

    String str=&quot;&quot;;
    for(int i=0;i&lt;100;i++){
        str=i+str;
    }

Is there a way to achieve this with StringBuilder? Thanks.



java: use StringBuilder to insert at the beginning

I&#39;ve a performance related question regarding use of StringBuilder.
In a very long loop I&#39;m manipulating a `StringBuilder` and passing it to another method like this:

    for (loop condition) {
        StringBuilder sb = new StringBuilder();
        sb.append(&quot;some string&quot;);
        . . .
        sb.append(anotherString);
        . . .
        passToMethod(sb.toString());
    }

Is instantiating `StringBuilder` at every loop cycle is a good solution? And is calling a delete instead better, like the following?

    StringBuilder sb = new StringBuilder();
    for (loop condition) {
        sb.delete(0, sb.length);
        sb.append(&quot;some string&quot;);
        . . .
        sb.append(anotherString);
        . . .
        passToMethod(sb.toString());
    }


Is it better to reuse a StringBuilder in a loop?

How do you append a new line(\n\r) character in `StringBuilder`?

Newline character in StringBuilder

I just encountered `StringBuilder` for the first time and was surprised since Java already has a very powerful `String` class that allows appending.

Why a second `String` class?

Where can I learn more about `StringBuilder`?

Why StringBuilder when there is String?

I understand the benefits of StringBuilder.

But if I want to concatenate 2 strings, then I assume that it is better (faster) to do it without StringBuilder. Is this correct?

At what point (number of strings) does it become better to use StringBuilder?



When to use StringBuilder?

I&#39;m trying to understand what the best practice is and why for concatenating string literals and variables for different cases. For instance, if I have code like this

    StringBuilder sb = new StringBuilder(&quot;AAAAAAAAAAAAA&quot;)
        .append(B_String).append(&quot;CCCCCCCCCCC&quot;).append(D_String)
        .append(&quot;EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE&quot;)
        .append(&quot;FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF&quot;);

Is this the way to do it? From [this post][1], I noticed that the `+` operator on Strings creates a new instance of StringBuilder, concatenates the operands, and returns a String conversion, which seems like a lot more work than just calling `.append()`; so if that&#39;s true, then that is out of the question. But what about `String.concat()`? Is it proper to use `.append()` for every concatenation? Or just for variables, and literals are okay to append with `.concat()`?

    StringBuilder sb = new StringBuilder(&quot;AAAAAAAAAAAAA&quot;)
        .append(B_String.concat(&quot;CCCCCCCCCCC&quot;)).append(D_String
        .concat(&quot;EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE&quot;)
        .concat(&quot;FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF&quot;));

What are the general rules for best practices and performance for going about these situations? Is my assumption correct on `+` and it should really just not be used?


  [1]: https://stackoverflow.com/questions/47605/java-string-concatenation

Best practices/performance: mixing StringBuilder.append with String.concat

In a [previous question][1] about formatting a `double[][]` to CSV format, [it was suggested][2] that using `StringBuilder` would be faster than `String.Join`. Is this true?


  [1]: https://stackoverflow.com/questions/585215/can-i-rewrite-this-more-elegantly-using-linq
  [2]: https://stackoverflow.com/questions/585215/can-i-rewrite-this-more-elegantly-using-linq/585223#585223

String.Join vs. StringBuilder: which is faster?

I just found some sql query build like this in my project:

    return (new StringBuilder(&quot;select id1, &quot; + &quot; id2 &quot; + &quot; from &quot; + &quot; table&quot;)).toString();

Does this `StringBuilder` achieve its aim, i.e reducing memory usage?

I doubt that, because in the constructor the &#39;+&#39; (String concat operator) is used. Will that take the same amount of memory as using String like the code below? s I understood, it differs when using `StringBuilder.append()`.

    return &quot;select id1, &quot; + &quot; id2 &quot; + &quot; from &quot; + &quot; table&quot;;

Are both statements equal in memory usage or not? Please clarify. 

Thanks in advance!

Edit:

BTW, **it is not my code**. Found it in an old project. Also, the query is not so small as the one in my example. :)



Correct way to use StringBuilder in SQL

What is the difference between `StringWriter` and `StringBuilder` and when should I use one or the other?

StringWriter or StringBuilder

I recently encountered with a Java 8 class [`StringJoiner`](https://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html) which adds the String using the delimiters and adds prefix and suffix to it, but I can&#39;t understand the need of this class as it also uses [`StringBuilder`](https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html) at the backend and also performs very simple operation of appending the Strings.

Am I missing something by not actually understanding the real purpose of this class?

Why StringJoiner when we already have StringBuilder?

What is the difference between `string` and `StringBuilder`? 

Also, what would be some examples for understanding?


Difference between string and StringBuilder in C#

I am little confused about using `StringBuilder` class, first:
&gt; A `string` object concatenation operation always creates a new object from the existing `string` and the new data. A `StringBuilder` object maintains a buffer to accommodate the concatenation of new data. New data is appended to the end of the buffer if room is available; otherwise, a new, larger buffer is allocated, data from the original buffer is copied to the new buffer, then the new data is appended to the new buffer.

But where is the point of creating `StringBuilder` instance to avoid creating new one of `String`? It sounds like trading &quot;one for one&quot;.

    static void Main(string[] args)
    {
        String foo = &quot;123&quot;;
        using (StringBuilder sb = new StringBuilder(foo)) // also sb isn&#39;t disposable, so there will be error
        {
            sb.Append(&quot;456&quot;);
            foo = sb.ToString();
        }

        Console.WriteLine(foo);
        Console.ReadKey();
    }

Why I shouldn&#39;t just use

    +=

***Edit:*** Ok, I know now how to reuse one instance of `StringBuilder` (still don&#39;t know if this is right with code standards), but this isn&#39;t worth to use with just one `string`, isn&#39;t it?

How to use StringBuilder wisely?

Someone told me that it&#39;s faster to concatenate strings with StringBuilder. I have changed my code but I do not see any Properties or Methods to get the final build string. 

How can I get the string?


StringBuilder: how to get the final String?

I have to use StringBuilder instead of a List of strings because of being stuck with .NET 1.1 for this project. 

I want to write a series of debug messages I&#39;ve written to a file to study at my leisure, as there is too much to see on the screen (the MessageBox doesn&#39;t have scrollbars). Some of the easy ways to write a file don&#39;t seem to be available in .NET 1.1. I also don&#39;t have access to `Environment.Newline` to cleanly separate the lines I append (`AppendLine` is not available in this archaic version of StringBuilder, either).

What is the easiest way in .NET 1.1 (C#) to write out the contents of the StringBuilder to a file? There is no &quot;C&quot; drive on the handheld device, so I reckon I will have to write it to &quot;\\hereIAm.txt&quot; or something.

What is the simplest way to write the contents of a StringBuilder to a text file in .NET 1.1?

I want to test if the `StringBuilder` is empty but there is no `IsEmpty` method or property.

How does one determine this?

How to check if a StringBuilder is empty?

What is the difference between String and StringBuffer in Java?

Is there a maximum size for String?

What is the difference between String and StringBuffer in Java?

What is the best method of writing a StringBuilder to a System.IO.Stream?

I am currently doing:

    StringBuilder message = new StringBuilder(&quot;All your base&quot;);
    message.Append(&quot; are belong to us&quot;);

    System.IO.MemoryStream stream = new System.IO.MemoryStream();
    System.Text.ASCIIEncoding encoding = new ASCIIEncoding();
    stream.Write(encoder.GetBytes(message.ToString()), 0, message.Length);


Write StringBuilder to Stream

A recent [question came up][1] about using String.Format(). Part of my answer included a suggestion to use StringBuilder.AppendLine(string.Format(...)).  Jon Skeet suggested this was a bad example and proposed using a combination of AppendLine and AppendFormat.

It occurred to me I&#39;ve never really settled myself into a &quot;preferred&quot; approach for using these methods.  I think I might start using something like the following but am interested to know what other people use as a &quot;best practice&quot;:

    sbuilder.AppendFormat(&quot;{0} line&quot;, &quot;First&quot;).AppendLine();
    sbuilder.AppendFormat(&quot;{0} line&quot;, &quot;Second&quot;).AppendLine();
    
    // as opposed to:
    
    sbuilder.AppendLine( String.Format( &quot;{0} line&quot;, &quot;First&quot;));
    sbuilder.AppendLine( String.Format( &quot;{0} line&quot;, &quot;Second&quot;));

  [1]: https://stackoverflow.com/questions/349659/stringformat-or-not


When do you use StringBuilder.AppendLine/string.Format vs. StringBuilder.AppendFormat?

Is there a way to append two string builders? 
And if so - does it perform better than appending a string to a StringBuilder ? 

How to append two stringBuilders?

How the StringBuilder class is implemented?  Does it internally create new string objects each time we append?

How the StringBuilder class is implemented? Does it internally create new string objects each time we append?

How does `StringBuilder` work? 

What does it do *internally*? Does it use unsafe code? 
And why is it so fast (compared to the `+` operator)?

How does StringBuilder work internally in C#?

I have a big CLOB (more than 32kB) that I want to read to a String, using StringBuilder. How do I do this in the most efficient way? I can not use the &quot;int length&quot; constructor for StringBuilder since the lenght of my CLOB is longer than a &quot;int&quot; and needs a &quot;long&quot; value.

I am not that confortable with the Java I/O classes, and would like to get some guidance.

&lt;b&gt;Edit&lt;/b&gt; - &lt;i&gt;I have tried with this code for clobToString():&lt;/i&gt;

    private String clobToString(Clob data) {
        StringBuilder sb = new StringBuilder();
        try {
            Reader reader = data.getCharacterStream();
            BufferedReader br = new BufferedReader(reader);
    
            String line;
            while(null != (line = br.readLine())) {
                sb.append(line);
            }
            br.close();
        } catch (SQLException e) {
            // handle this exception
        } catch (IOException e) {
            // handle this exception
        }
        return sb.toString();
    }

Most efficient solution for reading CLOB to String, and String to CLOB in Java?

I&#39;ve started using `StringBuilder` in preference to straight concatenation, but it seems like it&#39;s missing a crucial method. So, I implemented it myself, as an extension:

    public void Append(this StringBuilder stringBuilder, params string[] args)
    {
        foreach (string arg in args)
            stringBuilder.Append(arg);
    }

This turns the following mess:

    StringBuilder sb = new StringBuilder();
    ...
    sb.Append(SettingNode);
    sb.Append(KeyAttribute);
    sb.Append(setting.Name);

Into this:

    sb.Append(SettingNode, KeyAttribute, setting.Name);

I could use `sb.AppendFormat(&quot;{0}{1}{2}&quot;,...`, but this seems even less preferred, and still harder to read. Is my extension a good method, or does it somehow undermine the benefits of `StringBuilder`? I&#39;m not trying to prematurely optimize anything, as my method is more about readability than speed, but I&#39;d also like to know I&#39;m not shooting myself in the foot.

Am I undermining the efficiency of StringBuilder?

Has someone made a `StringBuilder` implementation in PHP? 


StringBuilder for PHP

In the book &quot;Effective Java&quot;, Josh Bloch says that 

&gt; StringBuffer is largely obsolete and should be replaced by the
&gt; non-synchronized implementation &#39;StringBuilder&#39;

. 

But in my experience, I&#39;ve still seen widespread use of the StringBuffer class. Why is the StringBuffer class now obsolete and why should StringBuilder be preferred over StringBuffer except for the increased performance due to non-synchronization?

StringBuffer is obsolete?

In [this answer][1], it says (implies) that String concatenation is optimised into StringBuilder operations anyway, so when I write my code, is there any reason to write StringBuilder code in the source? Note that my use case is different from the OP&#39;s question, as I am concatenating/appending hundreds-thousands of lines.

To make myself clearer: I am well-aware about the differences of each, it&#39;s just that I don&#39;t know if it&#39;s worth actually writing StringBuilder code because it&#39;s less readable and when its supposedly slower cousin, the String class, is converted automagically in the compilation process anyway.


  [1]:  https://stackoverflow.com/a/1532499/1154376

All Stringbuilder Solutions on Gang of Coders

Total of 36 Stringbuilder Solutions