There's no point creating a StringBuffer since the '+' operator's implementation already uses it, so code readability would be hindered for no real gain.
If you're using '+=', however, then there will be a difference since Strings in Java are immutable and so every new concatenation would be creating a new String object and tossing away the the old one. Here are the results of a simple test that I did:
~0s for 100,000 instantiations/concats
~0s for 1,000,000 instantiations/concats
0.1s for 100,000 instantiations/appends
1.1s for 1,000,000 instantiations/appends
0.5s for 100,000 instantiations/concats
4.6s for 1,000,000 instantiations/concats
They make me realize two things:
1. Using += within a loop is a bad idea
2. For a pragmatic person trying to refactor a large codebase, there doesn't seem to be much point focusing on micro-benchmarking for small values of n or for concatenations outside of a loop since the difference between any of the above techniques would negligible in such cases.
A small aside: The author of this article reads a bit into the Java Language Spec's section 18.104.22.168, which says: "...a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created..." and points out that the compiler is therefore not obligated to optimize the expression.