gogoWebsite

String comparison is a common operation, including comparing equality, comparing sizes, comparing prefix and suffix strings, etc. In Java, there are 3 common methods for comparing strings: equals() method, equalsIgnoreCase() method, and compareTo() method. The following is a detailed introduction to the use of these 3 methods.

equals() method

The equals() method will compare one by one whether each character of the two strings is the same. It returns true if both strings have the same character and length, otherwise it returns false. The case of characters is also within the range of checking. The syntax format of the equals() method is as follows:

str1.equals(str2);

str1 and str2 can be string variables or string literals. For example, the following expression is legal:

"Hello".equals(greeting)

The following code illustrates the use of the equals() method:

String str1 = "abc";
String str2 = new String("abc");
String str3 = "ABC";
System.out.println(str1.equals(str2)); // Output true
System.out.println(str1.equals(str3)); // Output false

equalsIgnoreCase() method

The function and syntax of the equalsIgnoreCase() method are exactly the same as the equals() method. The only difference is that equalsIgnoreCase() is case-insensitive when comparing. When comparing two strings, it will assume that A-Z and a-z are the same.

The following code illustrates the use of equalsIgnoreCase():

String str1 = "abc";
String str2 = "ABC";
System.out.println(str1.equalsIgnoreCase(str2));    // Output true

Comparison between equals() and ==

It is important to understand that the equals() method and the == operator perform two different operations. As explained just now, the equals() method compares characters in a string object. The == operator compares two object references to see if they refer to the same instance.

The following program explains how two different String objects can contain the same characters, but at the same time, the references of these objects are not equal:

String s1 = "Hello";
String s2 = new String(s1);
System.out.println(s1.equals(s2)); // Output true
System.out.println(s1 == s2); // Output false

Variable s1 points to a string instance created by "Hello". The object referred to by s2 is created with s1 as initialization. Therefore, the contents of these two string objects are the same. But they are different objects, which means that s1 and s2 do not point to the same object, so they are not ==.

Therefore, never use the == operator to test the equality of strings to avoid bad bugs in the program. On the surface, this bug is much like a randomly generated intermittent error.

For those who are accustomed to using C++'s String class, you must be very careful when performing equality detection. The String class in C++ overloads the == operator to detect equality of string content. Unfortunately, Java does not adopt this method. Its string "looks and feels" the same as the numeric value, but when performing equality tests, its operation is similar to a pointer. Language designers should have done special treatments like C++, i.e. redefining the == operator.

Of course, there are some inconsistencies in every language. C programmers never use == to compare strings, but use the strcmp function. Java's compareTo method is exactly similar to strcmp. So let’s introduce Java’s compareTo method.

compareTo() method

Generally, it is not enough to just know if two strings are the same. For sorting applications, it is necessary to know whether one string is greater than, equal to or smaller than the other. A string smaller than the other refers to it appearing first in the dictionary. And one string is larger than the other refers to it appearing after it is in the dictionary. The compareTo() method of a string implements this function.

The compareTo() method is used to compare the size of two strings in dictionary order, which is based on the Unicode value of each character of the string. The syntax format of the compareTo() method is as follows:

str.compareTo(String otherstr);

It compares the character sequence represented by str with the character sequence represented by the otherstr parameter in dictionary order. If str is before the othersr parameter in dictionary order, the comparison result is a negative integer; if str is behind othersr, the comparison result is a positive integer; if two strings are equal, the result is 0.

Tip: If two strings call equals() method returns true, calling compareTo() method will return 0.