Why string concatenation takes so long time? [duplicate]

Answer 1

Use a String Builder to append to strings.

When you concatenate, Java is actually creating a new String with the results of the concatenation. Do it multiple times and you are creating gazillion of strings for nothing.

Try:

StringBuilder sb = new StringBuilder();
for (String object : jsonData) { 
    counter++; 
    sb.append(object.toString());  //this does the concatenation internally
                                   //but is very efficient
}

finalJsonDataStr = sb.toString(); //this gives you back the whole string 

Remark:

When you do stuff like

myString = "hello " + someStringVariable + " World!" + " My name is " + name;

The compiler is smart enough to replace all that with a single StringBuilder, like:

myString = new StringBuilder("hello ")
                      .append(someStringVariable)
                      .append(" World!")
                      .append(" My name is ")
                      .append(name).toString();

But for some reason I don't know, it doesn't do it when the concatenation happens inside a loop.

Answer 2

You should use a StringBuffer or a StringBuilder.

When you add Strings with plus, a StringBuilder is created, strings are concatenated and a new String is return with toString() method of the StringBuilder. So image this object creation and string manipulation 50k times. It's much better if you instantiate only one StringBuilder yourself and just append strings...

This answer could be of use to you: concatenation operator (+) vs concat()

Answer 3

Before going to the actual problem, see how internal concatenation works.

String testString ="str"+"ingcon"+"catenation";  

If we print the above declared String to console and see, the result is stringconcatenation.Which is correct and the + works fine. Here is out actual question, how does that + symbol did the magic ? ? Is it not a normal mathematical addition of Strings. The below code snippet shows how that code with + actually converts.

 StringBuilder compilerGeneratedBuilder = new StringBuilder();  
 compilerGeneratedBuilder.append("str");  
 compilerGeneratedBuilder.append("ingcon");  
 compilerGeneratedBuilder.append("catenation");  
 String finalString = compilerGeneratedBuilder.toString(); 

More .....

50K times loop is a descent performance blocker to consider.

In such cases use StringBuilder with append method. Cause concat (+) create a new object every time a new String Builder object. That leads to 50k objects creations.

With single StringBuilder and append method, you can save the time of Objection creation as well as the memory too.