1. Overview
In this article, we’ll talk about the different ways of comparing Strings in Java.
As String is one of the most used data types in Java, this is naturally a very commonly used operation.
2. String Comparison With String Class
2.1. Using “==” Comparison Operator
Using the “==” operator for comparing text values is one of the most common mistakes Java beginners make. This is incorrect because “==”* only checks the referential equality of two *Strings, meaning if they reference the same object or not.
Let’s see an example of this behavior:
String string1 = "using comparison operator";
String string2 = "using comparison operator";
String string3 = new String("using comparison operator");
assertThat(string1 == string2).isTrue();
assertThat(string1 == string3).isFalse();
In the example above, the first assertion is true because the two variables point to the same String literal.
On the other hand, the second assertion is false because string1 is created with a literal and string3 is created using the new operator – therefore they reference different objects.
2.2. Using equals()
The String class overrides the equals() inherited from Object. This method compares two Strings character by character, ignoring their address.
It considers them equal if they are of the same length and the characters are in same order:
String string1 = "using equals method";
String string2 = "using equals method";
String string3 = "using EQUALS method";
String string4 = new String("using equals method");
assertThat(string1.equals(string2)).isTrue();
assertThat(string1.equals(string4)).isTrue();
assertThat(string1.equals(null)).isFalse();
assertThat(string1.equals(string3)).isFalse();
In this example, string1, string2, and string4 variables are equal because they have the same case and value irrespective of their address.
For string3 the method returns false, as it’s case sensitive.
Also, if any of the two strings is null, then the method returns false.
2.3. Using equalsIgnoreCase()
The equalsIgnoreCase() method returns a boolean value. As the name suggests this method ignores casing in characters while comparing Strings:
String string1 = "using equals ignore case";
String string2 = "USING EQUALS IGNORE CASE";
assertThat(string1.equalsIgnoreCase(string2)).isTrue();
2.4. Using compareTo()
The compareTo() method returns an int type value and compares two Strings character by character lexicographically based on a dictionary or natural ordering.
This method returns 0 if two Strings are equal*,* a negative number if the first String comes before the argument, and a number greater than zero if the first String comes after the argument String.
Let’s see an example:
String author = "author";
String book = "book";
String duplicateBook = "book";
assertThat(author.compareTo(book))
.isEqualTo(-1);
assertThat(book.compareTo(author))
.isEqualTo(1);
assertThat(duplicateBook.compareTo(book))
.isEqualTo(0);
2.5. Using compareToIgnoreCase()
The compareToIgnoreCase() is similar to the previous method, except it ignores case:
String author = "Author";
String book = "book";
String duplicateBook = "BOOK";
assertThat(author.compareToIgnoreCase(book))
.isEqualTo(-1);
assertThat(book.compareToIgnoreCase(author))
.isEqualTo(1);
assertThat(duplicateBook.compareToIgnoreCase(book))
.isEqualTo(0);
3. String Comparison With Objects Class
Objects is a utility class which contains a static equals() method, useful in this scenario – to compare two Strings.
The method returns true if two Strings are equal by first comparing them using their address i.e “==”. Consequently, if both arguments are null, it returns true and if exactly one argument is null, it returns false.
Otherwise, it then simply calls the equals() method of the passed argument’s type’s class – which in our case is String’s class equals() method. This method is case sensitive because it internally calls String class’s equals() method.
Let’s test this:
String string1 = "using objects equals";
String string2 = "using objects equals";
String string3 = new String("using objects equals");
assertThat(Objects.equals(string1, string2)).isTrue();
assertThat(Objects.equals(string1, string3)).isTrue();
assertThat(Objects.equals(null, null)).isTrue();
assertThat(Objects.equals(null, string1)).isFalse();
4. String Comparison With Apache Commons
**The Apache Commons library contains a utility class called StringUtils for String-related operations; this also has some very beneficial methods for String comparison.
4.1. Using equals() and equalsIgnoreCase()
The equals() method of StringUtils class is an enhanced version of the String class method equals(), which also handles null values:
assertThat(StringUtils.equals(null, null))
.isTrue();
assertThat(StringUtils.equals(null, "equals method"))
.isFalse();
assertThat(StringUtils.equals("equals method", "equals method"))
.isTrue();
assertThat(StringUtils.equals("equals method", "EQUALS METHOD"))
.isFalse();
The equalsIgnoreCase() method of StringUtils returns a boolean value. This works similarly to equals(), except it ignores casing of characters in Strings:
assertThat(StringUtils.equalsIgnoreCase("equals method", "equals method"))
.isTrue();
assertThat(StringUtils.equalsIgnoreCase("equals method", "EQUALS METHOD"))
.isTrue();
4.2. Using equalsAny() and equalsAnyIgnoreCase()
The equalsAny() method’s first argument is a String and the second is a multi-args type CharSequence. The method returns true if any of the other given Strings match against the first String case sensitively.
Otherwise, false is returned:
assertThat(StringUtils.equalsAny(null, null, null))
.isTrue();
assertThat(StringUtils.equalsAny("equals any", "equals any", "any"))
.isTrue();
assertThat(StringUtils.equalsAny("equals any", null, "equals any"))
.isTrue();
assertThat(StringUtils.equalsAny(null, "equals", "any"))
.isFalse();
assertThat(StringUtils.equalsAny("equals any", "EQUALS ANY", "ANY"))
.isFalse();
The equalsAnyIgnoreCase() method works similarly to the equalsAny() method, but also ignores casing:
assertThat(StringUtils.equalsAnyIgnoreCase("ignore case", "IGNORE CASE", "any")).isTrue();
4.3. Using compare() and compareIgnoreCase()
The compare() method in StringUtils class is a null-safe version of the compareTo() method of String class and handles null values by considering a null value less than a non-null value. Two null values are considered equal.
Furthermore, this method can be used to sort a list of Strings with null entries:
assertThat(StringUtils.compare(null, null))
.isEqualTo(0);
assertThat(StringUtils.compare(null, "abc"))
.isEqualTo(-1);
assertThat(StringUtils.compare("abc", "bbc"))
.isEqualTo(-1);
assertThat(StringUtils.compare("bbc", "abc"))
.isEqualTo(1);
The compareIgnoreCase() method behaves similarly, except it ignores casing:
assertThat(StringUtils.compareIgnoreCase("Abc", "bbc"))
.isEqualTo(-1);
assertThat(StringUtils.compareIgnoreCase("bbc", "ABC"))
.isEqualTo(1);
assertThat(StringUtils.compareIgnoreCase("abc", "ABC"))
.isEqualTo(0);
The two methods can also be used with a nullIsLess option. This is a third boolean argument which decides if null values should be considered less or not.
A null value is lower than another String if nullIsLess is true and higher if nullIsLess is false.
Let’s try it out:
assertThat(StringUtils.compare(null, "abc", true))
.isEqualTo(-1);
assertThat(StringUtils.compare(null, "abc", false))
.isEqualTo(1);
The compareIgnoreCase() method with a third boolean argument work similarly, except by ignoring case.
5. Conclusion
In this quick tutorial, we discussed different ways of comparing Strings.
And, as always, the source code for the examples can be found over on GitHub.