Java Language StringBuilder Comparing StringBuffer, StringBuilder, Formatter and StringJoiner
Example
The StringBuffer, StringBuilder, Formatter and StringJoiner classes are Java SE utility classes that are primarily used for assembling strings from other information:
-
The
StringBufferclass 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
StringBuilderclass was added in Java 5 to address performance issues with the originalStringBufferclass. The APIs for the two clases are essentially the same. The main difference betweenStringBufferandStringBuilderis 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
Formatterclass was added in Java 5, and is loosely modeled on thesprintffunction 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
StringJoinerclass 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:
StringBuildersuitable for any string assembly OR string modification task.StringBufferuse (only) when you require a thread-safe version ofStringBuilder.Formatterprovides much richer string formatting functionality, but is not as efficient asStringBuilder. This is because each call toFormatter.format(...)entails:- parsing the
formatstring, - creating and populate a varargs array, and
- autoboxing any primitive type arguments.
- parsing the
StringJoinerprovides succinct and efficient formatting of a sequence of strings with separators, but is not suitable for other formatting tasks.
