String Interpolation in Java

1. Overview

In this tutorial, we’ll discuss the topic of String interpolation in Java. We’ll look at a few different examples, and then go through some of the details.

2. String Interpolation in Java

String interpolation is a straightforward and precise way to inject variable values into a string. It allows users to embed variable references directly in processed string literals. Java lacks native support for String interpolation in comparison to languages like Scala.

However, there are some approaches to accomplish this behavior in Java. In the following sections, we’ll explain each one of these approaches.

3. Plus Operator

First, we have the “+” operator. We can use the “+” operator to concatenate our variables and string values. The variable is replaced by its value, so we achieve interpolation or concatenation of strings:

@Test
public void givenTwoString_thenInterpolateWithPlusSign() {
    String EXPECTED_STRING = "String Interpolation in Java with some Java examples.";
    String first = "Interpolation";
    String second = "Java";
    String result = "String " + first + " in " + second + " with some " + second + " examples.";
    assertEquals(EXPECTED_STRING, result);
}

As we can see in the previous example, with this operator, the resulting String contains the values of the variables “interpolate” with other string values. Since it may be adjusted to fit specific needs, this string concatenation method is among the most straightforward and valuable. When using the operator, we don’t need to put the text in quotations.

4. The format() Function

Another approach is using the format() method from the String class. Contrary to the “+” operator, in this case we need to use placeholders to get the expected result in the String interpolation:

@Test
public void givenTwoString_thenInterpolateWithFormat() {
    String EXPECTED_STRING = "String Interpolation in Java with some Java examples.";
    String first = "Interpolation";
    String second = "Java";
    String result = String.format("String %s in %s with some %s examples.", first, second, second);
    assertEquals(EXPECTED_STRING, result);
}

Additionally, we can reference a specific argument if we want to avoid variable repetitions in our format call:

@Test
public void givenTwoString_thenInterpolateWithFormatStringReference() {
    String EXPECTED_STRING = "String Interpolation in Java with some Java examples.";
    String first = "Interpolation";
    String second = "Java";
    String result = String.format("String %1$s in %2$s with some %2$s examples.", first, second);
    assertEquals(EXPECTED_STRING, result);
}

Now we’ve reduced unnecessary variable duplication, and instead used the index of the argument in the argument list.

5. StringBuilder Class

Our following approach is the StringBuilder class. We instantiate a StringBuilder object and then call the append() function to build the String. In the process, our variables are added to the resulting String:

@Test
public void givenTwoString_thenInterpolateWithStringBuilder() {
    String EXPECTED_STRING = "String Interpolation in Java with some Java examples.";
    String first = "Interpolation";
    String second = "Java";
    StringBuilder builder = new StringBuilder();
    builder.append("String ")
      .append(first)
      .append(" in ")
      .append(second)
      .append(" with some ")
      .append(second)
      .append(" examples.");
    String result = builder.toString();
    assertEquals(EXPECTED_STRING, result);
}

As we can see in the above code example, we may interpolate the strings with the necessary text by chaining the append function, which accepts the parameter as a variable (in this case, two Strings).

6. MessageFormat Class

Using the MessageFormat class is a lesser known method to obtain String interpolation in Java. With MessageFormat, we may create concatenated messages without worrying about the underlying language. It’s a standard method for creating user-facing messages. It takes an object collection, formats the strings contained within, and inserts them into the pattern at the proper locations.

MessageFormat‘s format method is nearly identical to String‘s format method, except for how the placeholders are written. Indexes like {0}, {1}, {2}, etc., represent the placeholder in this function:

@Test
public void givenTwoString_thenInterpolateWithMessageFormat() {
    String EXPECTED_STRING = "String Interpolation in Java with some Java examples.";
    String first = "Interpolation";
    String second = "Java";
    String result = MessageFormat.format("String {0} in {1} with some {1} examples.", first, second);
    assertEquals(EXPECTED_STRING, result);
}

Regarding performance, StringBuilder only appends text to a dynamic buffer; however, MessageFormat parses the given format before appending the data. As a result, StringBuilder outperforms MessageFormat in terms of efficiency.

7. Apache Commons

Finally, we have StringSubstitutor from Apache Commons. In the context of this class, values are substituted for variables included within a String. This class takes a piece of text and replaces all the variables. A variable’s default definition is ${variableName}. Constructors and set methods can be used to alter the prefix and suffixes. The resolution of variable values typically involves the use of a map. However, we can resolve them by utilizing system attributes or supplying a specialized variable resolver:

@Test
public void givenTwoString_thenInterpolateWithStringSubstitutor() {
    String EXPECTED_STRING = "String Interpolation in Java with some Java examples.";
    String baseString = "String ${first} in ${second} with some ${second} examples.";
    String first = "Interpolation";
    String second = "Java";
    Map<String, String> parameters = new HashMap<>();
    parameters.put("first", first);
    parameters.put("second", second);
    StringSubstitutor substitutor = new StringSubstitutor(parameters);
    String result = substitutor.replace(baseString);
    assertEquals(EXPECTED_STRING, result);
}

From our code example, we can see that we created a Map. The key names are the same as the names of the variables that we’ll replace in the String. Then we’ll put the corresponding value for each key into the Map. Next, we’ll pass it as a constructor argument to the StringSubstitutor class. Finally, the instantiate object calls the replace() function. This function receives as an argument the text with the placeholders. As a result, we get an interpolated text. And that’s all, simple.

8. Conclusion

In this article, we briefly discussed what String interpolation is. Then we learned how to achieve this in the Java language using native Java operators, the format() method from String class. Also, we explored lesser-known options, like MessageFormat and StringSubstitutor from Apache Commons. Finally, we looked at how to interpolate Strings using the new String template feature.