Best practices/performance: mixing StringBuilder.append with String.concat
java, string, string-concatenation, stringbuilder
Solution
`+` operator
String s = s1 + s2
Behind the scenes this is translated to:
String s = new StringBuilder(s1).append(s2).toString();
Imagine how much extra work it adds if you have `s1 + s2` here:
stringBuilder.append(s1 + s2)
instead of:
stringBuilder.append(s1).append(s2)
Multiple strings with `+`
Worth to note that:
String s = s1 + s2 + s3 + ... +sN
is translated to:
String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();
`concat()`
String s = s1.concat(s2);
`String` creates `char[]` array that can fit both `s1` and `s2`. Copies `s1` and `s2` contents to this new array. Actually requires less work then `+` operator.
`StringBuilder.append()`
Maintains an internal `char[]` array that grows when needed. No extra `char[]` is created if the internal one is sufficiently big.
stringBuilder.append(s1.concat(s2))
is also performing poorly because `s1.concat(s2)` creates an extra `char[]` array and copies `s1` and `s2` to it just to copy that new array contents to internal `StringBuilder` `char[]`.
That being said you should use `append()` all the time and append raw strings (your first code snippet is correct).
Problem
I'm trying to understand what the best practice is and why for concatenating string literals and variables for different cases. For instance, if I have code like this ``` StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA") .append(B_String).append("CCCCCCCCCCC").append(D_String) .append("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE") .append("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"); ``` Is this the way to do it? From this post, I noticed that the `+` operator on Strings creates a new instance of StringBuilder, concatenates the operands, and returns a String conversion, which seems like a lot more work than just calling `.append()`; so if that's true, then that is out of the question. But what about `String.concat()`? Is it proper to use `.append()` for every concatenation? Or just for variables, and literals are okay to append with `.concat()`? ``` StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA") .append(B_String.concat("CCCCCCCCCCC")).append(D_String .concat("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE") .concat("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")); ``` What are the general rules for best practices and performance for going about these situations? Is my assumption correct on `+` and it should really just not be used?