Kotlin String

An array of characters is called a string. Kotlin strings are similar to Java strings but have some newly added functionalities. They are also immutable, which means we can not change the elements and length of the String. 
The String class in Kotlin is defined as:  

class String : Comparable<String>, CharSequence

To declare a string in Kotlin, we need to use double quotes(" "); single quotes are not allowed to define Strings.

Syntax: 

var variable_name = "Hello, Geeks"   
or
var variable_name : String = "GeeksforGeeks"

Creating an empty String:

To create an empty string in Kotlin, we need to create an instance of the String class.

var variable_name = String()

String Elements and Templates

String Element

The character, digit, or any other symbol present in the string is called an element of a String. We can easily access the element of the string using string[index]. Elements are stored in a string from index 0 to (string.length - 1).
There are three ways in which you can access string elements in Kotlin

1. Using index: Returns the character at the specified index.
2. Using the get function: Returns the character at the specified index passed as an argument to the get function.
3. Iterating over the String: Using loops to access the characters in the String.

Kotlin program to access the elements of a string 

fun main(args: Array<String>){
    // accessing string 
      // elements one by one
    var str = "Hello"
    println(str[0])
    println(str[1])
    println(str[2])
    println(str[3])
    println(str[4])
    // accessing the string 
    // elements using for loop
    var str2 = "Geeks"
    for(i in str2.indices){
        print(str2[i]+" ")
    }
}

Output:

H
e
l
l
o
G e e k s 

String Template

String template expression is a piece of code that is evaluated and its result is returned into string. Both string types (escaped and raw string) contain template expressions. String templates starts with a dollar sign $ which consists of either a variable name or an arbitrary expression in curly braces. 

fun main(args: Array<String>) {
    var n = 10
    println("The value of n is $n")
    // using string 
    val str = "Geeks"
    println("$str is a string which length is ${str.length}")
}

Output: 

The value of n is 10
Geeks is a string which length is 5

String length

length: Returns the length of the String.

var s =" String"
println(s.length)

String get an element by index

get(index): Returns the character at that particular index.

s.get(3) // Output: - i

String subSequence

subSequence(start, end): Returns a substring starting from start and ending at end but excluding end.

s.subSequence(1, 4) // Output: - tri

String CompareTo

str.compareTo(string): Returns 0 if str == string.

var s1 = "GeeksForGeeks"
var s2 = "GeeksForGeeks"
s1.compareTo(s2) // Output:- 8

Parameters:

• s1: String 1 for comparison
• s2: String 2 for comparison

Returns:

• if string1 > string2, it returns positive number
• if string1 < string2, it returns negative number
• if string1 == string2, it returns 0
  

Kotlin program using the above properties and functions

fun main(args: Array<String>) {
    var g = "GeeksForGeeks"
    var e = "Geeks"
    println(g.length)
    println(g.get(4))
    println(g.subSequence(0, 5))
    println(g.compareTo(e))
}

Output:

13
s
Geeks
8

String Literals

There are two types of string literals in Kotlin -

1. Escaped String
2. Raw String

1. Escaped String

Escaped string is declared with double quotes ("....") and it may contain escape characters like \n, \t etc.

Kotlin program of escaped string: 

fun main(args: Array<String>) {
    // escaped string
    val str = "World \n is \n amazing"
    println(str)
}

Output: 

World 
 is 
 amazing

2. Raw String - Multi-line String

Raw string is placed inside the triple quotes ("""....""") and it does not have escape characters. It provides the facility of writing the string into multiple lines, so it is also called a multi-line string.

Kotlin program of raw string: 

fun main(args: Array<String>) {
    // raw string - multiline string
    var str = """My
        |name
        |is
        |Yash
    """.trimMargin()
    println(str)
}

Output: 

My
name
is
Yash

Escape Characters - Some of the escape characters are:

• \" : for double quote
• \r : for carriage return
• \n : for newline
• \' : for single quote
• \\ : for backslash
• \t : for tab
• \b : for backspace

String Equality

Kotlin provides an additional feature of comparing the instances of a particular type in two different ways. This feature makes Kotlin different than the other programming languages. 
The two types of equality are 

• Structural Equality
• Referential Equality

Structural Equality

Structural equality is checked through the == operator and its inverse != operator. By default, the expression containing x==y is translated into the call of the equals() function for that type.

Referential Equality

The referential equality in Kotlin is checked through the === operator and its inverse !== operator. This equality returns true only if both instances of a type point to the same location in memory. When used on types that are converted into a primitive type at runtime, the === check is converted into == check, and !== check is converted into != check.

Kotlin program to demonstrate the structural and referential equality

fun main(args: Array<String>) {
    var x = "GeeksForGeeks"
    var y = "GeeksForGeeks"
    var z = "Geeks"
    println(x===y) // true , as both are pointing to the same StringPool
    println(x==z)  //false since values are not equal
    println(x===z) // false
}

Output: 

true
false
false