StringBuilder vs String concatenation in toString() in Java

Version 1 is preferable because it is shorter and the compiler will in fact turn it into version 2 - no performance difference whatsoever.

More importantly given we have only 3 properties it might not make a difference, but at what point do you switch from concat to builder?

At the point where you're concatenating in a loop - that's usually when the compiler can't substitute StringBuilder by itself.

The key is whether you are writing a single concatenation all in one place or accumulating it over time.

For the example you gave, there's no point in explicitly using StringBuilder. (Look at the compiled code for your first case.)

But if you are building a string e.g. inside a loop, use StringBuilder.

To clarify, assuming that hugeArray contains thousands of strings, code like this:

...String result = "";for (String s : hugeArray) {    result = result + s;}

is very time- and memory-wasteful compared with:

...StringBuilder sb = new StringBuilder();for (String s : hugeArray) {    sb.append(s);}String result = sb.toString();

In most cases, you won't see an actual difference between the two approaches, but it's easy to construct a worst case scenario like this one:

public class Main{    public static void main(String[] args)    {        long now = System.currentTimeMillis();        slow();        System.out.println("slow elapsed " + (System.currentTimeMillis() - now) + " ms");        now = System.currentTimeMillis();        fast();        System.out.println("fast elapsed " + (System.currentTimeMillis() - now) + " ms");    }    private static void fast()    {        StringBuilder s = new StringBuilder();        for(int i=0;i<100000;i++)            s.append("*");          }    private static void slow()    {        String s = "";        for(int i=0;i<100000;i++)            s+="*";    }}

The output is:

slow elapsed 11741 msfast elapsed 7 ms

The problem is that to += append to a string reconstructs a new string, so it costs something linear to the length of your strings (sum of both).

So - to your question:

The second approach would be faster, but it's less readable and harder to maintain.As I said, in your specific case you would probably not see the difference.