Comparing StringBuffer StringBuilder Formatter and StringJoiner
suggest changeThe StringBuffer
, StringBuilder
, Formatter
and StringJoiner
classes are Java SE utility classes that are primarily used for assembling strings from other information:
- The
StringBuffer
class has been present since Java 1.0, and provides a variety of methods for building and modifying a “buffer” containing a sequence of characters. - The
StringBuilder
class was added in Java 5 to address performance issues with the originalStringBuffer
class. The APIs for the two clases are essentially the same. The main difference betweenStringBuffer
andStringBuilder
is that the former is thread-safe and synchronized and the latter is not.
This example shows how StringBuilder
is can be used:
int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.
(The StringBuffer
class is used the same way: just change StringBuilder
to StringBuffer
in the above)
The StringBuffer
and StringBuilder
classes are suitable for both assembling and modifying strings; i.e they provide methods for replacing and removing characters as well as adding them in various. The remining two classes are specific to the task of assembling strings.
- The
Formatter
class was added in Java 5, and is loosely modeled on thesprintf
function in the C standard library. It takes a format string with embedded format specifiers and a sequences of other arguments, and generates a string by converting the arguments into text and substituting them in place of the format specifiers. The details of the format specifiers say how the arguments are converted into text. - The
StringJoiner
class was added in Java 8. It is a special purpose formatter that succinctly formats a sequence of strings with separators between them. It is designed with a fluent API, and can be used with Java 8 streams.
Here are some typical examples of Formatter
usage:
// This does the same thing as the StringBuilder example above
int one = 1;
String color = "red";
Formatter f = new Formatter();
System.out.print(f.format("One=%d, colour=%s%n", one, color));
// Prints "One=1, Colour=red" followed by the platform's line separator
// The same thing using the `String.format` convenience method
System.out.print(String.format("One=%d, color=%s%n", one, color));
The StringJoiner
class is not ideal for the above task, so here is an example of a formatting an array of strings.
StringJoiner sj = new StringJoiner(", ", "[", "]");
for (String s : new String[]{"A", "B", "C"}) {
sj.add(s);
}
System.out.println(sj);
// Prints "[A, B, C]"
The use-cases for the 4 classes can be summarized:
StringBuilder
suitable for any string assembly OR string modification task.StringBuffer
use (only) when you require a thread-safe version ofStringBuilder
.Formatter
provides much richer string formatting functionality, but is not as efficient asStringBuilder
. This is because each call toFormatter.format(...)
entails:
- parsing the `format` string,
- creating and populate a *varargs* array, and
- autoboxing any primitive type arguments.
StringJoiner
provides succinct and efficient formatting of a sequence of strings with separators, but is not suitable for other formatting tasks.