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
firstName = "Mark" // can be changed
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`.
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.
