How you can use compareTo() and different string actions in Kotlin

Kotlin is a statically typed programming language, which implies each variable ought to have one fastened kind. There are numerous built-in Kotlin sorts, one in all which is the String kind.

We use the String kind to retailer string values, that are sequences of characters surrounded by double quotes. We are able to then work with these saved string values in numerous methods.

Let’s be taught extra about Kotlin strings and tips on how to work with them. On this information:

What are strings in Kotlin?

Let’s check out an instance to know Kotlin strings higher:

val firstName: String = "Kingsley"    

Right here, the identify of the variable is firstName, the kind is String, and the worth contained in the double quotes "" is Kingsley.

Since we’re assigning the worth of the variable equal to Kingsley instantly, we will get rid of the kind definition. Because of this, the variable under is equally legitimate:

val firstName = "Kingsley"    

This handy Kotlin characteristic is known as kind inference. Mainly, it signifies that the compiler can routinely deduce the kind of a variable, so we don’t have to particularly point out it.

Working with strings in Kotlin

A brand new String object is initialized each time we use "" to create a string. This object supplies us with a number of built-in properties and strategies to assist us work with the string worth.

Properties give us details about a given string worth, akin to its size, the place of particular characters within the string, and so forth.

Strategies are features that we will name on an object to immediately manipulate its worth. For instance, we may name a way on a string to return a subset of the unique string.

Let’s go over tips on how to carry out some generally used string actions in Kotlin.

Retrieving particular person characters of a Kotlin string by index

Every character in a string is represented by an index, which is simply an integer worth. As in most programming languages, we begin counting the index from 0. The primary character within the string can have an index of 0, the second can have an index of 1, and so forth.

We are able to retrieve a personality within the string utilizing its distinctive index, like so:

enjoyable important() {
    val greeting = "Hello Kingsley"       

    println(greeting[0]) // H
    println(greeting[1]) // i
    println(greeting[2]) // whitespace
    println(greeting[3]) // Ok
}

Checking if a string is empty in Kotlin

We are able to examine if a variable has an empty string worth utilizing the strategy isEmpty().

Right here’s an instance of checking for an empty string:

enjoyable important() {
    val emptyStr = ""       

    println(emptyStr.isEmpty()) // true
}

isEmpty() returns a boolean worth of true if the string is empty and false if the string incorporates any characters.

Getting the size of a string in Kotlin

Think about you have got a program by which you need to abbreviate all names that exceed a given size. To take action, it’s essential to first get the size of every string.

The size property returns the variety of characters current contained in the string:

enjoyable important() {
    val greeting = "Hello Kingsley"       

    println(greeting.size) // 11
}

All characters contained in the string are counted, together with whitespaces.

Getting a string subset in Kotlin

To chop out a portion of a bigger string, use Kotlin’s substring() methodology.

substring() extracts the portion of a string that’s between a offered begin and finish index. Within the instance under, we’re extracting all characters between the sixth index and eleventh index:

enjoyable important() {
    val greeting = "Whats up Worldd"       

    println(greeting.substring(6, 11)) // World
}

Notice that the character on the sixth index is just not included, however the character on the eleventh index is included.

Becoming a member of strings in Kotlin

String concatenation is when two or extra strings are merged. A easy method to merge two or extra strings is with the addition + operator:

enjoyable important() {
    val firstName = "Kingsley"   
    val lastName = "Ubah"   
    val fullName = firstName + lastName

    println(fullName) // KingsleyUbah
}

You may separate each strings by whitespace or some other character:

enjoyable important() {
    val firstName = "Kingsley"   
    val lastName = "Ubah"   
    val fullName = firstName + " " + lastName

    println(fullName) // Kingsley Ubah
}

You may also use + to embed variables inside a bigger string:

enjoyable important() {
    val buyer = "Kingsley"
    val totalAmount = 50
    val gadgets = 6

    val msg = "Hello " + buyer + ", your cart has a complete of " + gadgets + " gadgets and so they quantity to " + totalAmount + " {dollars}"

    println(msg)
}

Notice that repeated concatenation utilizing + can shortly make your code harder to learn. You need to use a template string to keep away from this drawback.

A template string permits you to immediately embed variables in the principle string. With template strings, it’s very simple to identify any lacking house.

To incorporate variables in a template string, precede every variable identify with a greenback signal $, as proven within the instance under:

enjoyable important() {
    val buyer = "Kingsley"
    val totalAmount = 50
    val gadgets = 6

    val msg = "Hello $buyer, your cart has a complete of $gadgets gadgets and so they quantity to $totalAmount {dollars}"

    println(msg) 
}

Template strings are one of many some ways to make your code cleaner and extra readable in Kotlin.

Utilizing comparability operators to check Kotlin strings

You need to use comparability operators in Kotlin to examine if two or extra string objects are structurally or referentially equal.

Structural comparability checks if two or extra objects have the identical worth. To examine for this sort of equality, we use the double equal signal ==. Right here’s an primary instance:

enjoyable important() {
    val a = "Whats up"
    val b = "Hallo"
    val c = "Whats up"

    println(a == b)   // returns false
    println(a == c)   // returns true

}

As a result of a and c each have the identical worth, evaluating them with == returns true.

Take into account that the comparability is case-sensitive. Which means uppercase and lowercase letters are interpreted as being totally different, so the string “hey” is just not the identical as “Whats up”.

Referential comparability checks if two or extra variables level to the identical object. For referential comparability, we use the triple equal signal ===, as seen within the instance under:

enjoyable important() {
    val str_1 = "Whats up"    
    val str_2 = "Whats up"
    val str_3 = "Whats up World"

    println(str_1 === str_2) // true     
    println(str_1 === str_3) // false
}

The reference comparability between str_1 and str_2 returns true as a result of when the second project is made, the Java Digital Machine (JVM) discovers that the string “Whats up” already exists throughout the pool.

Making the second variable level to the identical string object, “Whats up,” saves some reminiscence.

Nevertheless, JVM allocates separate reminiscence for the third variable project as a result of the worth is totally different. Therefore, the comparability between str_1 and str_3 returns false.

Utilizing the equals() operate to check Kotlin strings

The equals() operate needs to be acquainted to these coming from a Java background. Much like ==, which we noticed earlier, equals() checks if two objects have the identical content material.

Let’s take a look at an instance utilizing this simple methodology to check strings. Under, we outlined 4 string variables. Out of the 4, solely a and c are the identical.

enjoyable important() {
    val a = "Whats up"
    val b = "Hallo"
    val c = "Whats up"
    val d = "hey"

    println(a.equals(b))    // returns false
    println(a.equals(c))     // returns true
    println(a.equals(d, true))     // returns true
}

Notice that equals() checks are case-sensitive by default, so the string “hey” is just not the identical as “Whats up”.

Nevertheless, not like with ==, we will select to take away case sensitivity by passing a second argument of true in equals(). We did this within the final line, the place we in contrast “Whats up” to “hey” and the examine returned true.

Utilizing the compareTo() operate to check Kotlin strings

You may also examine strings in Kotlin with compareTo(). Right here is the essential syntax for this methodology:

mainStr.compareTo(otherStr)

Whereas the earlier strategies return a boolean worth (true or false), compareTo() returns an integer:

• Returns 0 if the principle string and the opposite string are equal
• Returns a damaging quantity if the opposite string’s ASCII worth is greater than the principle string
• Returns a constructive quantity if the opposite string’s ASCII worth is smaller than the principle string

// Instance 1
enjoyable important() {
val a = "Hallo"
val b = "Whats up"

println(a.compareTo(b))    // returns -4

}

// Instance 2
enjoyable important() {
val a = "Whats up"
val b = "Hallo"

println(a.compareTo(b))    // returns 4

}

// Instance 3
enjoyable important() {
val a = "Whats up"
val b = "Whats up"

println(a.compareTo(b))    // returns 0

}

compareTo() string comparisons are case-sensitive by default. Like with equals(), you possibly can override this habits by passing the argument true.

Within the following instance, the primary examine returns a damaging worth as a result of we explicitly enabled case sensitivity. The second examine returns 0 as a result of we disabled case sensitivity.

enjoyable important() {
    val higher: String = "Whats up"
    val decrease: String = "hey"


    println(higher.compareTo(decrease, false))    // returns false (-32)
    println(higher.compareTo(decrease, true))     // returns true (0)

}

Changing strings in Kotlin

The String.exchange() methodology is used to exchange strings in Kotlin. The fundamental syntax is as follows:

mainString.exchange(oldValue, newValue)

This methodology checks for occurrences of the offered previous worth inside the principle string and replaces each occasion with the brand new worth. Right here’s an instance:

enjoyable important() {
    var mainStr = "Changing Strings in Python"
    val oldValue = "Python"
    val newValue = "Kotlin"

    val newStr = mainStr.exchange(oldValue, newValue)

    println(newStr) // Changing Strings in Kotlin
}

To disable case sensitivity, go true because the third argument. Let’s see this in motion:

var mainStr = "Changing Strings in python"    
    val oldValue = "Python"
    val newValue = "Kotlin"

    var newStr = mainStr.exchange(oldValue, newValue, true)
    println(newStr) // Changing Strings in Kotlin

As you possibly can see, the case distinction between “python” and “Python” was ignored.

Sorting strings in Kotlin

We are able to kind a string alphabetically in Kotlin by executing the strategies toCharArray(), sorted(), and joinToString() on the string in succession.

Suppose you need to reorder the string “elephant” to be in alphabetical order: “aeehlnpt”. First, convert the string to an array with the toCharArray() methodology. Then, use sorted() to kind the array. Lastly, use joinToString() to show the array again right into a String:

enjoyable important() {
    val str = "elephant"
    val arr = str.toCharArray()
    val sorted = arr.sorted().joinToString("")
    println(sorted) // aeehlnpt
}

You may wrap all the things inside a customized operate and name that operate everytime you need to kind a string:

enjoyable sortByAlpha(str: String) {       
    val arr = str.toCharArray()
    println(arr.sorted().joinToString(""))

}
enjoyable important() {
    sortByAlpha("elephant")
}

Abstract

On this tutorial, we realized about Kotlin strings and tips on how to carry out some widespread Kotlin string operations. These embrace getting a string size, sorting strings, becoming a member of strings, evaluating strings, and utilizing a string template to make your string readable.

I hope you discovered this complete information to Kotlin strings useful. If you wish to be taught much more, Kotlin supplies in depth documentation on strings that goes past the properties and strategies we reviewed on this publish to cowl associated ideas, akin to Kotlin extensions.

Have an awesome week.