Strings
Strings in Kotlin are represented by the type String
.
Generally, a string value is a sequence of characters in double quotes ("
):
Elements of a string are characters that you can access via the indexing operation: s[i]
. You can iterate over these characters with a for
loop:
Strings are immutable. Once you initialize a string, you can't change its value or assign a new value to it. All operations that transform strings return their results in a new String
object, leaving the original string unchanged:
To concatenate strings, use the +
operator. This also works for concatenating strings with values of other types, as long as the first element in the expression is a string:
String literals
Kotlin has two types of string literals:
Escaped strings
Escaped strings can contain escaped characters.
Here's an example of an escaped string:
Escaping is done in the conventional way, with a backslash (\
).
See Characters page for the list of supported escape sequences.
Multiline strings
Multiline strings can contain newlines and arbitrary text. It is delimited by a triple quote ("""
), contains no escaping and can contain newlines and any other characters:
To remove leading whitespace from multiline strings, use the trimMargin()
function:
By default, a pipe symbol |
is used as margin prefix, but you can choose another character and pass it as a parameter, like trimMargin(">")
.
String templates
String literals may contain template expressions – pieces of code that are evaluated and whose results are concatenated into a string. When a template expression is processed, Kotlin automatically calls the .toString()
function on the expression's result to convert it into a string. A template expression starts with a dollar sign ($
) and consists of either a variable name:
or an expression in curly braces:
You can use templates both in multiline and escaped strings. To insert the dollar sign $
in a multiline string (which doesn't support backslash escaping) before any symbol, which is allowed as a beginning of an identifier, use the following syntax:
String formatting
To format a string to your specific requirements, use the String.format()
function.
The String.format()
function accepts a format string and one or more arguments. The format string contains one placeholder (indicated by %
) for a given argument, followed by format specifiers. Format specifiers are formatting instructions for the respective argument, consisting of flags, width, precision, and conversion type. Collectively, format specifiers shape the output's formatting. Common format specifiers include %d
for integers, %f
for floating-point numbers, and %s
for strings. You can also use the argument_index$
syntax to reference the same argument multiple times within the format string in different formats.
Let's look at an example:
The String.format()
function provides similar functionality to string templates. However, the String.format()
function is more versatile because there are more formatting options available.
In addition, you can assign the format string from a variable. This can be useful when the format string changes, for example, in localization cases that depend on the user locale.
Be careful when using the String.format()
function because it can be easy to mismatch the number or position of the arguments with their corresponding placeholders.