Java String compareTo() Method with Examples
This article will look at an inbuilt method called the compareTo() method in Java programming language. Let’s directly jump into the topic without beating around the bush by looking at the compareTo() method’s necessity, advantages, and syntax.
Finally, we will look at a couple of codes that illustrate using the compareTo() method. To grasp the concept faster and master it quickly, I suggest you practice each code in the article, try to make some modifications, and tinker with the code to cover different scenarios.
What does the compareTo() method In Java do?
The compareTo() method is an inbuilt part of the JavaString class. It is used to compare strings with the current string lexicographically. Upon checking, this function either returns a positive or negative value; if the strings match, it returns 0. Lexical order is the same as alphabetical order. This method compares letters in a string one by one, starting from the beginning.
The compareTo() method compares two strings based on the Unicode value of each character in the strings. This method is defined in the java.lang.Comparable interface.
When do we use the CompareTo() method in Java?
The compareTo() method is handy while performing natural sorting on a string. Natural sorting refers to the sorting order that applies to the object, like lexical order for String, numeric order for Sorting integers, and more.
What is the syntax of the compareTo() method?
Before we proceed with the examples and working of this method, let us discuss the syntax of the compareTo() method:
<String1>.compareTo(String2)
The above syntax compares string1 and string2 lexicographically. The compareTo() method takes in a string in its parameter list. This method has a return type of int. Let’s touch a little bit more on the topic of the method’s return type.
The function returns a positive number if String1 is greater than String2, a negative number if String2 is greater than String1, and a return if String1 is equal to String2.
What is the internal working of the compareTo() method in Java?
Sometimes it is very crucial to know what is happening behind the curtains. Thus, let us take a look at a user-defined function that shows the working of the compareTo() function:
public class FirstCode
{
public static int stringCompare(String str1, String str2)
{
int l1 = str1.length();
int l2 = str2.length();
int lmin = Math.min(l1, l2);
for (int i = 0; i < lmin; i++)
{
int str1_ch = (int)str1.charAt(i);
int str2_ch = (int)str2.charAt(i);
if (str1_ch != str2_ch) {return str1_ch - str2_ch;}
}
if (l1 != l2) {return l1 - l2;}
else {return 0;}
}
public static void main(String args[])
{
String string1 = new String("FirstCode");
String string2 = new String("First");
String string3 = new String("Code");
String string4 = new String("Code");
System.out.println("The difference in length between " +string2 + " and "+string1+ " : " +stringCompare(string2, string1));
System.out.println("The difference in length between " +string3 + " and " + string4+ " : " +stringCompare(string3, string4));
System.out.println("The difference in length between " +string1 + " and " + string4 + " : " +stringCompare(string1, string4));
}
}
Output:
The difference in length between First and FirstCode: -4
The difference in length between Code and Code : 0
The difference in length between FirstCode and Code : 3
In the above example, the user-defined function “stringCompare” was used to compare the lengths of the input strings. The difference between the lengths is printed if the strings are not the same length.
Now that we know the theory about the compareTo() method let us implement this knowledge in some programs by experimenting with its implementation.
How to check if 2 Strings are the same using the compareTo() method
The compareTo() method returns the “o” when two strings are the same. Here is an example:
class Main
{
public static void main(String[] args)
{
String str1 = "FirstCode";
String str2 = "FirstCode";
if (str1.compareTo(str2) == 0)
{System.out.println("String1 and String2 are equal");}
else { System.out.println("String1 and String2 are not equal");}
}
}
Output:
String1 and String2 are equal
How to compare an object with a string using compareTo() in Java?
The compareTo() method can also compare an object to a string; here is an example:
public class Main
{
public static void main(String args[])
{
String str1 = "FirstCode";//String
String str2 = new String("FirstCode");//object
String str3 = new String("Gopi");//object
System.out.print("Comparing FirstCode(obj) and FirstCode(str) : ");
System.out.println(str1.compareTo(str2));
System.out.print("Comparing Gopi(obj) and FirstCode(str) : ");
System.out.println(str1.compareTo(str3));
System.out.print("Comparing Gopi(obj) and FirstCode(obj) : ");
System.out.println(str2.compareTo(str3));
}
}
Output:
Comparing FirstCode(obj) and FirstCode(str) : 0
Comparing Gopi(obj) and FirstCode(str) : -1
Comparing Gopi(obj) and FirstCode(obj) : -1
How do you ignore a case while comparing strings using compareTo()?
We cannot directly use the compareTo() method to ignore the case of the strings. However, the built Java method String.equalsIgnoreCase() compares two strings irrespective of the case of the string, which means that they can be either lower or upper case.
The equalsIgnoreCase() method is similar to the String.equals() method in that it returns true if the argument is not null and the contents of both the Strings are the same; otherwise, it is false. However, the equalsIgnoreCase() method ignores the case of the strings. The syntax is similar to the String.equals() method.
For example, to compare string1 to string2 while ignoring their case, use the following syntax:
string1.equalsIgnoreCase(string2);
Here is a program that makes use of the String.equalsIgnoreCase():
public class FirstCode
{
public static void main(String args[])
{
String string1 = new String("First");
String string2 = new String("Code");
String string3 = new String("FirstCode");
String string4 = new String("FirstCode");
String string5 = new String("firstcode");
System.out.println(string1+" and " +string2+ " : " +string1.equalsIgnoreCase(string2));
System.out.println(string3+" and " +string4+ " : " +string3.equalsIgnoreCase(string4));
System.out.println(string4+" and " +string5+ " : " +string4.equalsIgnoreCase(string5));
System.out.println(string1+" and " +string4+ " : " +string1.equalsIgnoreCase(string4));
}
}
First and Code : false
FirstCode and FirstCode : true
FirstCode and firstcode : true
First and FirstCode : false
Can we compare an empty string using the compareTo() method?
Yes, we can. If you compare two strings, and either the first or second string is empty, the method returns the length of the non-empty string. In other words, if the first string is empty, the method returns a negative number. If the second string is empty, the process returns the length of the first string.
Here is an example illustrating the same:
public class Main
{
public static void main(String args[])
{
String s1="FirstCode";
String s2="";
String s3="Gopi";
System.out.println(s1.compareTo(s2));
System.out.println(s2.compareTo(s3));
}
}
Output:
9
-4
What are the exceptions of using the compareTo() method in Java?
While using the compareTo() method in Java, we most commonly come across two exceptions; let us take a look at both of them:
1. classCastException
The ClassCastException is thrown by the compiler when incompatible object types are compared. In the program shown below, an object of the ArrayList (al) is being compared with a string literal (“Gopi”), and since we can’t compare an array with a string, the compiler throws an error.
import java.util.*;
class FirstCodeEmployee
{
private String name;
public FirstCodeEmployee(String str)
{name = str;}
}
public class Main
{
public static void main(String[] args)
{
FirstCodeEmployee ronaldo = new FirstCodeEmployee("Gopi");
FirstCodeEmployee sachin = new FirstCodeEmployee("Ram");
FirstCodeEmployee messi = new FirstCodeEmployee("Seeta");
ArrayList<FirstCodeEmployee> al = new ArrayList<>();
al.add(ronaldo);
al.add(sachin);
al.add(messi);
Collections.binarySearch(al, "Gopi", null);
}
}
Output:
2. NullPointerException
Another exception we can encounter while using the compareTo() method is the NullPointerException. This exception is invoked when the compareTo() method is invoked by a null pointer.
Here is an example:
public class Main
{
public static void main(String[] args)
{
String str = null;
System.out.println(str.compareTo("FirstCode"));
}
}
Output:
Conclusion
In summary, the compareTo() method in Java belongs to the java.lang.String class is a valuable tool for lexicographically comparing strings. It plays a key role in natural sorting scenarios, providing quick insights into the relative order of two strings based on positive, negative, or zero return values.
However, developers must handle potential exceptions, such as ClassCastException and NullPointerException, to ensure robust code. Additionally, for case-insensitive comparisons, the dedicated equalsIgnoreCase() method proves helpful, making the compareTo() method a versatile asset for efficient string comparisons in Java applications.