kotlin-string-template

In this tutorial, we’ll explain what Kotlin’s String templates are and how to use them.

In order to get familiar with other features and to know how to use Kotlin, have a look at one of our Kotlin tutorials.

Like in Java, Strings in Kotlin are immutable. That means that we have no means to alter a String once it’s created. However, we may derive another String from a given one.

Kotlin has enriched Java String class with additional functionality.

For example, the method padEnd() allows us to format a String, so that the expression:

Which produces a new string “Hello!!!!!”.

String templates are String literals that contain embedded expressions.

For example, this code in Java:

In Kotlin is just:

Any valid Kotlin expression may be used in a String template:

Unlike Java, many Kotlin’s constructs (but certainly, not all) are expressions.

Therefore, a String template may contain logic as well:

Notice that inside the curly brackets there’s a valid Kotlin expression. This is a reason why we don’t escape the nested double quotes.

String templates are resolved by evaluating the expression and invoking a toString() method on the result of the evaluation.

String templates can be nested:

The String template parser starts to resolve it from the most nested template, evaluates it and invokes a toString() method on it.

Though the String templates may be nested, it’s a good idea to have them as simple as possible. This isn’t difficult at all because Kotlin provides us with many useful tools.

What if we want to use a raw dollar sign and not as a part of a String template?

Then we escape it by putting a backslash in front of it:

What follows the dollar sign becomes a usual String – it isn’t evaluated anymore and it is interpreted as is.

In Kotlin, additionally, we have triple-quoted raw Strings that can contain special characters without the need for escaping them.

The resulting String is contained between two consecutive non-overlapping occurrences of triple double-quote-signs “.

For example, in Java, in order to create properly a String containing a Windows-style file path to a resource located at C:\Repository\read.me, we should define it in this way:

In Kotlin, we may use the triple-quoted notation in order to achieve the same result:

We may use this notation in order to create a multi-line String:

Which creates a String that spans exactly two lines. If we prefer this indentation:

We use a trimMargin() method that eliminates eventual white spaces from the start of every line up to the first occurrence of the margin prefix (> in the example above).

Triple-quoted strings don’t support any escape sequences. It means that if we wrote

in order to get a two-line String, we’d get a single line containing the characters \n instead of the expected line break.

Triple-quoted Strings do support templating though. 

It means that any sequence starting with the dollar sign gets resolved to a string in a way as we have described in the previous section. We may use this fact in order to make the escape characters work:

In this article, we’ve considered one feature of the Kotlin language that is absent in Java – String templates. We’ve illustrated their usage in case of usual and multi-line Strings.

You may find all code snippets mentioned here in our repository on GitHub.