Why StringBuilder is much faster than String

Do you understand how it works internally?

Every time you do stringA += stringB; a new string is created an assigned to stringA so it will consume memory (new string instance!) and time (copy the old string + new chars of the other string).

StringBuilder will use internally an array of chars and when you use .append() method it will do several things:

• check if there are any free space for the string to append
• again some internal checks and run a System.arraycopy to copy the chars of the string in the array.

Personally, i think the allocation of a new string every time (creating a new instance of string, put the string etc.) could be very expansive in terms of memory and speed (in while/for etc. especially).

In your example, use a StringBuilder is better but if you need (example) something simple like a .toString()

public String toString() {
    return StringA + " - " + StringB;
}

makes no differences (well, in this case is better you avoid StringBuilder overhead which is useless here).

Strings in java are immutable. This means that methods that operate on strings cannot ever change the value of a string. String concatenation using += works by allocating memory for an entirely new string that is the concatenation of the 2 previous ones, and replacing the reference with this new string. Each new concatenation requires the construction of an entirely new String object.

In constrast, the StringBuilder and StringBuffer classes are implemented as a mutable sequence of characters. This means that as you append new Strings or chars onto a StringBuilder, it simply updates its internal array to reflect the changes you've made. This means that new memory is only allocated when the string grows past the buffer already existing in a StringBuilder.