Is it better practice to use String.format over string Concatenation in Java?

java

string-format

string-concatenation

performance

byAnton Shumikhin·Jan 9, 2025

Choose String.format for its advantages in clarity and localization, since it cleanly separates text and variables. Utilize concatenation with + or StringBuilder when dealing with simple string joinings without specific formatting needs.

Example (String.format):

String message = String.format("Hello, %s. Score: %d.", "John", 120);

Example (concatenation):

String message = "Hello, " + "John" + ". Score: " + 120 + ".";

Why choose String.format?

String.format comes up strong when you are up against localization challenges. It keeps template strings and dynamic content separate. This abstraction leads to easier translations:

ResourceBundle messages = ResourceBundle.getBundle("messages", Locale.US);
String template = messages.getString("greeting");
String message = String.format(template, "John", 120);

With explicit argument positions, String.format also adds clarity to the order and formatting of inserted variables, and lets you reuse the same value:

String info = String.format("%1$s owes %2$.2f dollars. %1$s paid %2$.2f.", "Alice", 250.00);

StringBuilder and performance

Regardless of the ease of String.format, StringBuilder takes the crown when prioritizing performance. Especially in loops, efficient usage of StringBuilder makes the tedious task of repetition less overwhelming:

StringBuilder builder = new StringBuilder(); // Efficient instantiation
for (int i = 0; i < largeNumber; i++) {
    builder.append(i).append(" "); // Brace yourself, the loop is coming!
}

Pretty contagious, huh? However, please don't rush to be judgmental about concatenation with +. The good folks at JVM take that and optimize it into a StringBuilder sequence. Hence, for simple concatenations, + remains readability's friend.

Advanced formatting with String.format

String.format also gives you nifty tools for text manipulation that concatenation just doesn't provide:

String fancyStr = String.format("Total: %08d; Date: %tB %<te, %<tY", 123, new Date());

String.format lets you insert variables into strings in a type-safe manner. Cheers to localization people, you're not forgotten here!

Readability and personal preference

The subjectiveness of readability can tip the balance for or against String.format or concatenation. What do you value most, structure, or simplicity?

`String.format`: "I love the structure and reuse of format tokens." 🏗️
vs.
Concatenation: "Quick to write and understand at a glance." 💨

You might find concatenation more appealing in making code easier to comprehend:

String url = protocol + "://" + domain + ":" + port + "/"; // No worries, it's not rocket science!

Security considerations

There's always a dark side, and String.format is no exception. It shares a bed with printf, and can bump into its vulnerabilities. Especially be wary of careless handling of format specifiers:

try {
    String output = String.format("%s %s", "hello"); // Oh no, we're one %s short. This won't end well!
} catch (java.util.MissingFormatArgumentException e) {
    System.err.println("A format specifier expected company. It's lonely!");
}