Named placeholders in string formatting

java

string-formatting

messageformat

stringtemplate

byNikita Barsukov·Nov 26, 2024

Apache Commons Text's StringSubstitutor provides a neat solution for named placeholders in Java:

import org.apache.commons.text.StringSubstitutor;

Map<String, String> values = new HashMap<>();
values.put("user", "Bob");
values.put("action", "coding");
String template = "Our hero, ${user}, is ${action}.";

String result = new StringSubstitutor(values).replace(template);
System.out.println(result); // "Our hero, Bob, is coding."

Attach the library and use the map for on-the-fly swaps in your string template.

Relevance of StringSubstitutor

For dealing with a complex web of placeholders in your strings, StringSubstitutor brings readability and maintainability to the table, isolating your template from the data feeding it.

Diverse Paths to Placeholder Substitution

Unpacking the power of MessageFormat

Java's in-built MessageFormat provides a medium for working with named placeholders, freeing you from the need of external dependencies:

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;

Map<String, Object> values = new HashMap<>();
//Everyone loves a movie break!
values.put("movie", "The Matrix");
values.put("time", 2.5);
String pattern = "Now showing: {movie} for {time} hours.";

MessageFormat format = new MessageFormat(pattern);
String message = format.format(values);
System.out.println(message); // "Now showing: The Matrix for 2.5 hours."

Tap into the robustness and economy of the native universe with MessageFormat, particularly when dealing with recurring values or string patterns.

Venturing into StringTemplate for advanced templates

When in need of complex templating and dictionary-like structure support, shield up with StringTemplate from ANTLR:

import org.antlr.stringtemplate.StringTemplate;

StringTemplate template = new StringTemplate(
    "Dear $name$, you've won a $item$! Congratulations!"
);
//And they say money can't buy happiness
template.setAttribute("name", "Jane");
template.setAttribute("item", "million dollars");

String result = template.toString();
System.out.println(result); // "Dear Jane, you've won a million dollars! Congratulations!"

Just ensure you have ANTLR's StringTemplate library as your faithful companion to embark on this quest.

Placeholder Substitution: Trade Secrets

Weighing the scale for tool choice

Beyond the excitement of using named placeholders in your code, pause to assess the volume and complexity of placeholders. For a handful of placeholders, MessageFormat can fit the bill. For templates that bear the resemblance of a configuration file, opt for StringSubstitutor or StringTemplate.

Library adoption: A double-edged sword

While libraries like StringSubstitutor can be a godsend to manage numerous placeholders, remember they carry with them additional dependencies affecting your project's build size and compatibility. Swing the sword with caution.

Avoiding potholes

Keep an eye for missing keys in your map or placeholder typos — these uninvited guests can crash your party. Always host validation checks and unit testing for an error-free feast.

Right tool for you: A quick checklist

Here's a brief list to help you make an informed choice:

Simplicity: How user-friendly is the API? Could your grandma use it?
Functionality: Does it provide the bells and whistles such as iteration over collections, conditionals, or complex expressions?
Performance: Does it slow down your app or does it sizzle with speed?
Community support: Is it several thousand developers strong, or are you the lone ranger here?