As we know, two strings are equal if they have the same sequence of characters. In this short tutorial, we’ll see various approaches to comparing Strings in Scala.
2. String Comparison Using the == Method
Let’s see how to compare two Strings using the == method:
val stringOne = "baeldung" val stringTwo = "baeldung" assert(stringOne == stringTwo)
Here, the == method checks for the equality of stringOne and stringTwo and returns true.
Alternatively, we can also write it as:
assert(stringOne eq stringTwo)
Comparing strings with the == method has a major advantage – it doesn’t throw a NullPointerException even if a String is null:
val stringOne = "baeldung" val stringTwo = null assert(stringOne != stringTwo)
The above code prints a Boolean value false. Internally, the == method checks for null values first and then calls the equals() method of the first String object to check for their equality.
However, the method == doesn’t compare the Strings in a case-sensitive manner. So, if we change the value of stringOne to “Baeldung”, it will again print false:
val stringOne = "Baeldung" val stringTwo = "baeldung" assert(stringOne != stringTwo)
In such situations, when we want to do a case-insensitive comparison, we can convert both the Strings to upper case or lower case and then compare:
assert(stringOne.toUpperCase() == stringTwo.toUpperCase())
Finally, we should also be aware that calling such methods on a null String throws a NullPointerException.
3. String Comparison Using the equals() Method
We can make use of the equals() method of the String class to check for the equality of two Strings:
However, if the two Strings have a different case, the above assertion will fail.
In such cases, we can use the equalsIgnoreCase() method:
Most importantly, we must ensure that the String calling the equals() method is not null. Otherwise, it will throw a NullPointerException.
4. Equality: Scala vs. Java
The concept of equality is defined differently in Java and Scala. Java has essentially two ways to evaluate equality – the == operator that strictly checks for reference equality and the equals() method that, if overridden, checks for the contents of the objects.
Conversely, in Scala, the == method is reserved for comparing any type naturally. This means x == y is true if they refer to the same object. Subsequently, x == y is also true if they hold the same primitive value.
Further, the == is a final method defined in the class Any. It’s written as eq in Scala.
In the case of comparing references in Scala, the == method behaves the same as equals(). But, we can always change the behavior of equals() by overriding it in the classes we define. However, we cannot override == as it’s a final method.
In this article, we discussed how to compare two Strings using the == and equals() methods. We also explored how to do case-insensitive comparisons.
As always, the full source code for the examples can be found over on GitHub.