Difference between concatenating strings and using StringBuffer append

Question

The static content has been hard coded in Java files like this:

String s = "<span class=\"className\">StaticContent</span>";

It has to be externalized using ResourceBundle objects.

A simple method of doing it is:

String s = "<span class=\"className\">" + 
           ResourceBundleObject.getString("StaticContent.key") + "</span>";

The second method is using StringBuilder object:

StringBuilder sb = new StringBuilder();
sb.append("<span class=\"className\">");
sb.append(ResourceBundleObject.getString("StaticContent.key"));
sb.append("</span>");
String s = sb.toString();

Does second method have advantage over the first one (in terms of resources consumed)?

It's easier to use first method as it involves very less editing.

Trivikram If you care about performance it's better to use StringBuilder (for reasons already explained by others already). If you need a conventient way I would suggest something like: private final String TEMPLATE = "<span class=\"className\">%s</span>" and create your Strings using String.format(String, Object...). For example String s = String.format(TEMPLATE,ResourceBundleObject.getString("StaticContent.key")). This method is not efficient at all but is programmaticly convenient. — Pantelis Sopasakis
– Pantelis Sopasakis, Commented Feb 22, 2011 at 10:19

Andreas Dolk · Accepted Answer · 2011-02-22 09:29:10Z

One concatenation of Strings creates a new String object:

"a" + "b" + "c" + "d"      // 4 Strings
"ab"                       // 1 String
"abc"                      // 1 String
"abcd"                     // 1 String
                           // 7 String instances in total (& in theory / worst case)

StringBuilder creates less objects:

StringBuilder sb = new StringBuilder("a").append("b").append("c").append("d")
                           // 4 Strings, 1 StringBuilder 
                               = 5 objects (in theory/worst case)

But the compiler is aware of this problem and if you look at the class files byte code, often enough you see that string concatenations have been replaced with StringBuilder and append. Haveing that in mind, you can focus on readable code and leave it to the compiler to find the most performant solution.

Personally, I only use a dedicated StringBuilder if I have to assemble large Strings (like java source or html pages) or if I use loops to assemble the Strings, like this:

 String result = "";
 for (int i = 0; i < 100; i++)
   result += ".";    // Ouch - this should be done with StringBuilder

Stephen C · Accepted Answer · 2011-02-22 10:12:06Z

2

In this case, there is no performance advantage of using an explicit StringBuilder.

The JLS states that the Java compiler is allowed to compile a sequence of String concatenation subexpressions into an equivalent creation of a temporary StringBuilder and sequence of append calls. In this case, the optimization works, and the compiler will generate bytecodes that are effectively the same as the bytecodes you'd get if you used StringBuilder yourself. In other words, the only net effect of using StringBuilder is to make your code harder to read.

You are only likely to get a performance advantage by using StringBuilder explicitly if your code does concatenation in a loop. However, if you build long strings this way, the performance difference can be significant.

edited Feb 22, 2011 at 10:12

answered Feb 22, 2011 at 10:06

Stephen C

723k95 gold badges849 silver badges1.3k bronze badges

3 Comments

Trivikram Over a year ago

Does default Java compiler "javac" uses this optimization while concatenating strings in sequence?

Stephen C Over a year ago

Yes. It is easy to confirm: - just use javap to examine a classfile.

Trivikram Over a year ago

Hats off to you Stephen C. I wrote two sample functions and checked them using "javap -c". No doubt StringBuilder is useful in loop, but in sequential concatenation there's no significant performance advantage. Actually, using StringBuilder in such cases will make code difficult to read.

pauljwilliams · Accepted Answer · 2011-02-22 09:20:50Z

1

Strings are immutable - once they're created they cant be modified.

So if you do string1 + string2, string2 isnt merely copied to the end of string1 - a new string is created that holds the concatenated string. If you do a whole sequence of these operations it can get very expensive.

You should note, howevere, that under the covers, the JVM converts string cncatenation code (using +) into a sequence of stringbuilder calls. So in fact your two snippets should compile to the smae (or very similar) bytecode.

As ever, test and measure if you want optimal performance.

answered Feb 22, 2011 at 9:20

pauljwilliams

19.3k3 gold badges54 silver badges80 bronze badges

2 Comments

Trivikram Over a year ago

How can I test or measure the performance of the two methods? Can you suggest the way/tool to be used?

pauljwilliams Over a year ago

Depends on what you want to measure. Memory usage? Speed? Object creation count? You should decide what metrics are important in your situation and then searching this site - chances are its been covered. If not, ask a new question.

Dead Programmer · Accepted Answer · 2011-02-22 09:29:36Z

1

 1. First One will create three Instance.  // "" will create 2 temp instance , concat using + another instance 
 2. Second One wil create One Instance.

 - the String class is an immutable class.
 - It will never really change internally. When you use the operator
   it actually  do not change the string itself, but rather return a
   new String.

 - StringBuilder is more efficient as it is designed with no thread-safety in mind.
 - Will appends to it the previous value of the string.
 - if you are building long strings, then using StringBuilder
 - no synchronization is performed.
 - StringBuilder lacks some methods split,search

edited Feb 22, 2011 at 9:29

answered Feb 22, 2011 at 9:18

Dead Programmer

12.6k23 gold badges83 silver badges113 bronze badges

Comments

Deepak · Accepted Answer · 2011-02-22 09:23:54Z

0

The second method has definitely advantage over the first since in case of first we are creating a new string object with the new operator which is Immutable but in case of String Builder as the name suggests we are appending to the original string,thereby we are not creating extra new String objects,Thereby saving memory in case of String Buiilder.String Builder like String Buffer is also Mutable.

answered Feb 22, 2011 at 9:23

Deepak

2,1129 gold badges35 silver badges48 bronze badges

Collectives™ on Stack Overflow

Difference between concatenating strings and using StringBuffer append

5 Answers 5

Comments

3 Comments

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

3 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related