286 lines
4.5 KiB
Markdown
286 lines
4.5 KiB
Markdown
---
|
|
title: Strings
|
|
---
|
|
|
|
# Strings
|
|
|
|
A string is a basic data type in a programming language. Strings are represented by the type `String`. Strings are immutable. Kotlin has a rich API for working with strings.
|
|
|
|
### Basic Usage
|
|
|
|
#### Declaration
|
|
|
|
```kotlin
|
|
// Explicit type declaration
|
|
var firstName : String = "Elon"
|
|
|
|
// or Implicit type declaration and will still compile
|
|
val lastName = "Musk"
|
|
```
|
|
|
|
In addition, notice the usage of `val` variable type, here is how it behaves
|
|
|
|
```kotlin
|
|
var firstName = "Mark" // can be changed
|
|
val lastName = "Zuckerberg" // cannot be changed
|
|
lastName = 12 // Error: type mismatch
|
|
```
|
|
|
|
#### String Concatenation
|
|
|
|
Shown in the code snippet, just like Java, appending `Int` to
|
|
`String` will result to a `String` output
|
|
|
|
```kotlin
|
|
var str = "abc" + 1
|
|
println(str + "def")
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
abc1def
|
|
```
|
|
|
|
Even without explicitly converting `Int` value 1 to `String` object first, the resulting output is still a `String`.
|
|
|
|
### String templates
|
|
|
|
String templates are a much easy and nice way of concatenate and generate strings:
|
|
```kotlin
|
|
var a = 1
|
|
// simple name in template:
|
|
val s1 = "a is $a"
|
|
|
|
println(s1)
|
|
```
|
|
|
|
Output:
|
|
```shell
|
|
a is 1
|
|
```
|
|
|
|
The template also allows the use of functions:
|
|
|
|
```kotlin
|
|
a = 2
|
|
// arbitrary expression in template:
|
|
val s2 = "${s1.replace("is", "was")}, but now is $a"
|
|
|
|
println(s2)
|
|
```
|
|
|
|
Output:
|
|
```shell
|
|
a was 1, but now is 2
|
|
```
|
|
|
|
#### String with Multiple Lines
|
|
|
|
Programmers can declare `String` variables with multiple lines by using triple quotes instead of double quotes
|
|
|
|
```kotlin
|
|
var str = """
|
|
This is line 1
|
|
This is line 2
|
|
This is line 3
|
|
"""
|
|
println(str)
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
This is line 1
|
|
This is line 2
|
|
This is line 3
|
|
```
|
|
|
|
or with `.trimIndent()`
|
|
|
|
The use of `trimIndent()` will additionally help to provide a clean output format by removing excess and unnecessary indentions on each line. Examine the code snippet below:
|
|
|
|
```kotlin
|
|
var str = """
|
|
This is line 1
|
|
This is line 2
|
|
This is line 3
|
|
""".trimIndent()
|
|
println(str)
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
This is line 1
|
|
This is line 2
|
|
This is line 3
|
|
```
|
|
|
|
### Accessing Characters of a String
|
|
|
|
#### Index Access
|
|
Programmers can access elements (characters) of a string using index access operator:
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
println(str[2])
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
a
|
|
```
|
|
|
|
It's just like accessing an element from an array, you get:
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
println(str[9]) // Error: index out of bounds
|
|
```
|
|
|
|
#### Iterate through a String
|
|
|
|
Elements of a string are characters that can be accessed by the indexing operation: `s[i]`.
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
for (c in str) {
|
|
println(c)
|
|
}
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
E
|
|
x
|
|
a
|
|
m
|
|
p
|
|
l
|
|
e
|
|
```
|
|
|
|
### Immutability of a String
|
|
|
|
Just like Java, you cannot change individual elements of a `String`
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
str[2] = "b" // Error
|
|
```
|
|
|
|
#### Re-assigning String values
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
println(str)
|
|
str = "Example was changed"
|
|
println(str)
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
Example
|
|
Example was changed
|
|
```
|
|
|
|
### String Properties
|
|
|
|
#### Determining length of a String
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
println(str.length)
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
7
|
|
```
|
|
|
|
### String Functions
|
|
|
|
These are some of the common `String` functions available from the current Kotlin version
|
|
|
|
### compareTo
|
|
|
|
Compares this object with the specified object for order. Returns zero if this object is equal to the specified other object, a negative number if it's less than other, or a positive number if it's greater than other.
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
var str2 = "Example123"
|
|
var str3 = "Example12345"
|
|
println(str.compareTo(str2))
|
|
println(str.compareTo(str3))
|
|
println(str3.compareTo(str))
|
|
println(str.compareTo("Example"))
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
-3
|
|
-5
|
|
5
|
|
0 # Equal
|
|
```
|
|
|
|
### equals
|
|
|
|
Indicates whether a `String` object is exactly equal to another `String` object
|
|
|
|
```kotlin
|
|
var str = "Example"
|
|
var str2 = "Example2"
|
|
println(str.equals("Example"))
|
|
println(str2.equals("Example"))
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
true
|
|
false
|
|
```
|
|
|
|
### get
|
|
|
|
Returns the character at the specified index in this character sequence.
|
|
|
|
``` kotlin
|
|
var str = "Example"
|
|
println(str.get(3))
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
m
|
|
```
|
|
|
|
### toString
|
|
|
|
Returns a string representation of the object.
|
|
|
|
```kotlin
|
|
println(9.toString() + 10)
|
|
println(9 + 10)
|
|
```
|
|
|
|
Output:
|
|
|
|
```shell
|
|
910 // Here 910 is a string value.
|
|
19
|
|
```
|
|
|
|
#### Resources
|
|
|
|
* [Kotlin Basic Types](https://kotlinlang.org/docs/reference/basic-types.html)
|
|
* [Kotlin String Reference](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/index.html)
|