28

What is the benefit and trade-off of using a string builder over pure string concatenation?

new StringBuilder(32).append(str1)
                     .append(" test: ")
                     .append(val)
                     .append(" is changed")
                     .toString();

vs say 

str1 + " test: " + val + " is changed".

str1 is a random 10 character string. str2 is a random 8 character string.

JosEduSol
  • 5,268
  • 3
  • 23
  • 31
Chun ping Wang
  • 3,879
  • 12
  • 42
  • 53
  • In your trivial example, there may be no benefit. StringBuilders are useful because, when you concat with + you create brand new strings every time you concat. StringBuilder is therefore more efficient for concat'ing large numbers of strings. – Robert Harvey Aug 26 '13 at 21:39

2 Answers2

53

In your particular example, none because the compiler internally uses StringBuilders to do String concatenation. If the concatenation occurred in a loop, however, the compiler could create several StringBuilder and String objects. For example:

String s= "" ;
for(int i= 0 ; i < 10 ; i++ )
    s+= "a" ;

Each time line 3 above is executed, a new StringBuilder object is created, the contents of s appended, "a" appended, and then the StringBuilder is converted into a String to be assigned back to s. A total of 10 StringBuilders and 10 Strings.

Conversely, in

StringBuilder sb= new StringBuilder() ;
for(int i= 0 ; i < 10 ; i++ )
    sb.append( "a" );
String s= sb.toString() ;

Only 1 StringBuilder and 1 String are created.

The main reason for this is that the compiler could not be smart enough to understand that the first loop is equivalent to the second and generate more efficient (byte) code. In more complex cases, it's impossible even for the smartest compiler to know. If you absolutely need this optimization, you have to introduce it manually by using StringBuilders explicitly.

Mario Rossi
  • 7,651
  • 27
  • 37
5

The quick answer is the performance: when you are using native String classes it operates immutable strings, which means when you are writing

  String line = "java";
  String sufix = " is awesome";
  line = line + sufix;

it will create two strings "java" and " is awesome", than create a new third string "java is awesome" from previous two ("java" and "is awesome") which later are likely to be deleted by a garbage collector (because they are no more used in app). That is a slow solution.

More faster solution is an appliance of StringBuffer class which through the smart algorightms that provide a buffer (that is obvious from its name) for merging strings and as a result would not remove the initial string during the concatenation process.

In case you are writing single thread-application (no concurrancy issues during which multiple threads access same object) it is better to apply StringBuilder which has even faster performance than the initial StringBuffer class.

SMBiggs
  • 11,034
  • 6
  • 68
  • 83
  • Hi, like Thread safe data structures, you suggest using a Thread safe version of String Builder in multi threaded execution ? – nmxprime Sep 17 '14 at 05:45