{"id":5690,"date":"2023-09-29T07:01:39","date_gmt":"2023-09-29T06:01:39","guid":{"rendered":"https:\/\/www.baeldung.com\/java-21-string-templates"},"modified":"2023-09-29T07:01:39","modified_gmt":"2023-09-29T06:01:39","slug":"string-templates-in-java-21","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2023\/09\/29\/string-templates-in-java-21\/","title":{"rendered":"String Templates in Java 21"},"content":{"rendered":"

\"\"<\/p>\n

1. Introduction<\/h2>\n
<\/div>\n

In this tutorial, we’ll talk about Java’s answer to String interpolation – String templates. This pre-release preview feature was introduced as part of Java 21 with JEP 430<\/a>.<\/p>\n

2. String Composition in Java<\/h2>\n
<\/div>\n

We use Strings<\/em> to represent sequences of numbers, letters, and symbols to represent text in code. Strings<\/em> are ubiquitous in programming, and we often need to compose strings to use in code. There are several ways to do that, and each technique has its downsides.<\/p>\n

2.1. String Concatenation<\/h3>\n
<\/div>\n

String concatenation<\/a> is the most basic action we use to build strings. We take strings literals and expressions and then use the +<\/em> symbol to compose them together:<\/p>\n

String composeUsingPlus(String feelsLike, String temperature, String unit){\r\n    return "Today's weather is " + feelsLike + \r\n      ", with a temperature of " + temperature + " degrees " + unit;\r\n}<\/code><\/pre>\n
This code achieves the desired functionality but is hard to read, especially with all the plus symbols, and also difficult to maintain and change.<\/strong><\/p>\n
2.2. StringBuffer<\/em> or StringBuilder<\/em><\/h3>\n
<\/div>\n
We can use utility classes Java provides, such as the StringBuilder<\/em> and StringBuffer<\/em><\/a> classes. These classes provide us with the append()\u00a0<\/em>library function to compose strings, thereby removing the usage of + <\/em>in string composition:<\/p>\n
String composeUsingStringBuilder(String feelsLike, String temperature, String unit) {\r\n    return new StringBuilder()\r\n      .append("Today's weather is ")\r\n      .append(feelsLike)\r\n      .append(", with a temperature of ")\r\n      .append(temperature)\r\n      .append(" degrees ")\r\n      .append(unit)\r\n      .toString();\r\n}<\/code><\/pre>\n
StringBuilder<\/em> and StringBuffer<\/em> classes provide efficient String manipulation and composition techniques while reducing memory overheads. However, they follow the Builder<\/em> design pattern and hence become quite verbose.<\/strong><\/p>\n
2.3. String Formatter<\/h3>\n
<\/div>\n
Java provides us with the capability to separate the static part of the String and the parameters, such as the temperature<\/em> and the unit<\/em> with the String.format()<\/a> <\/em>or the formatted()<\/em> methods:<\/p>\n
String composeUsingFormatters(String feelsLike, String temperature, String unit) {\r\n    return String.format("Today's weather is %s, with a temperature of %s degrees %s", \r\n      feelsLike, temperature, unit);\r\n}<\/code><\/pre>\n
The base template string remains static. However, the order and the number of arguments passed here are crucial for the correctness of its response.<\/strong><\/p>\n
2.4. MessageFormat<\/em> class<\/h3>\n
<\/div>\n
Java provides a MessageFormat<\/em> class of the Java.text<\/em> package that helps in the composition of text messages with placeholders for dynamic data. Localisation<\/em><\/a> and Internationalisation<\/em> heavily use this. We can use MessageFormat.format()<\/em> in plain String composition:<\/p>\n
String composeUsingMessageFormatter(String feelsLike, String temperature, String unit) {\r\n    return MessageFormat.format("Today''s weather is {0}, with a temperature of {1} degrees {2}",\r\n      feelsLike, temperature, unit);\r\n}<\/code><\/pre>\n
This also shares a similar downside as that of the above. Additionally, the syntax structure differs from how we write and use strings in code.<\/p>\n
3. Introduction to String Templates<\/h2>\n
<\/div>\n
As we saw, all the String composition techniques mentioned above come with their shortcoming. Let’s see how String templates can help with those.<\/p>\n
3.1. Goals<\/h3>\n
<\/div>\n
String templates are introduced to the Java programming ecosystem with the following goals in mind:<\/p>\n