StringBuilder vs String concatenation in toString() in Java – Dev

The best answers to the question “StringBuilder vs String concatenation in toString() in Java” in the category Dev.


Given the 2 toString() implementations below, which one is preferred:

public String toString(){
    return "{a:"+ a + ", b:" + b + ", c: " + c +"}";


public String toString(){
    StringBuilder sb = new StringBuilder(100);
    return sb.append("{a:").append(a)
          .append(", b:").append(b)
          .append(", c:").append(c)


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


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) {
String result = sb.toString();


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.


I prefer:

String.format( "{a: %s, b: %s, c: %s}", a, b, c );

…because it’s short and readable.

I would not optimize this for speed unless you use it inside a loop with a very high repeat count and have measured the performance difference.

I agree, that if you have to output a lot of parameters, this form can get confusing (like one of the comments say). In this case I’d switch to a more readable form (perhaps using ToStringBuilder of apache-commons – taken from the answer of matt b) and ignore performance again.


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();
        System.out.println("slow elapsed " + (System.currentTimeMillis() - now) + " ms");

        now = System.currentTimeMillis();
        System.out.println("fast elapsed " + (System.currentTimeMillis() - now) + " ms");

    private static void fast()
        StringBuilder s = new StringBuilder();
        for(int i=0;i<100000;i++)

    private static void slow()
        String s = "";
        for(int i=0;i<100000;i++)

The output is:

slow elapsed 11741 ms
fast 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.