1. Overview
In this tutorial, we’ll discuss different ways of comparing Strings in Kotlin.
2. Comparison Operators
Let’s start with the “==” operator.
We can use it to check if two strings are structurally equal. It’s the equivalent of using the equals method in Java:
val first = "kotlin"
val second = "kotlin"
val firstCapitalized = "KOTLIN"
assertTrue { first == second }
assertFalse { first == firstCapitalized }
Now, let’s consider the referential equality operator “===”. It returns true if the two variables are pointing to the same object. It’s the equivalent of using == in Java.
Whenever we initialize a new String object using quotes, it’s automatically placed in the string pool. Therefore, two equal strings created that way will always reference the same object:
assertTrue { first === second }
However, if we use a constructor to create a new String, we explicitly tell Kotlin we want a new object. Consequently, a new String will be created and put on the heap:
val third = String("kotlin".toCharArray())
assertTrue { first == third }
assertFalse { first === third }
3. Comparing with equals
The equals method returns the same result as the “==” operator:
assertTrue { first.equals(second) }
assertFalse { first.equals(firstCapitalized) }
When we want to do a case-insensitive comparison, we can use the equals method and pass true for the second optional parameter ignoreCase:
assertTrue { first.equals(firstCapitalized, true) }
4. Comparing with compareTo
Kotlin also has a compareTo method which we can use to compare the order of the two strings. Similarly, as the equals method, the compareTo method also comes with an optional ignoreCase argument:
assertTrue { first.compareTo(second) == 0 }
assertTrue { first.compareTo(firstCapitalized) == 32 }
assertTrue { firstCapitalized.compareTo(first) == -32 }
assertTrue { first.compareTo(firstCapitalized, true) == 0 }
The compareTo method returns zero for equal strings, a positive value if the argument’s ASCII value is smaller, and a negative value if the argument’s ASCII value is greater. In a way, we can read it like we read subtraction.
In the last example, due to the ignoreCase argument*,* the two strings are considered equal*.*
5. Conclusion
In this quick article, we saw different ways of comparing strings in Kotlin using some basic examples.
As always, please check out all the code over on GitHub.