What is Java String compareTo() Method?
The java string class compareTo() method returns the 0 value if both strings are lexicographically equal. If the compared string is greater lexicographically then the positive value is returned otherwise the negative value is returned. So the Java string compareTo() method is used to compare two strings. The unicode value of each character in the string is always used by this method to compare them. While comparing the strings, if any of them is empty, it always returns the length of the string. If any of the strings is empty, then two scenarios can play out. If the first string is empty then it returns a negative value, otherwise it returns a positive value. The Java string.compareTo() method by default is case sensitive but we can use Java String class compareToIgnoreCase() method to ignore case sensitivity during comparison. This method also returns a negative, 0, or a positve integer as described above.Syntax
public int compareTo(string str)
public int compareTo(object obj)
Key points about the syntax:
- Access Modifier: The method is
public, making it accessible to all classes. - Return Type: The method returns an integer value that indicates the lexical comparison result.
- Method Name: The method is named
compareTo, following the naming convention for comparison methods. - Parameter: The method takes a single parameter,
anotherString, which is the string to compare against the current string.
Parameters
The Java string compareTo() method receives a string or an object as a parameter as you can see above in the syntax.Detailed Parameter Information
To use the compareTo() method effectively, it is essential to understand its parameter:
- Parameter Type: The method accepts a parameter of type
String. - Role: The parameter represents the string to be compared with the string object that invokes the method.
- Case Sensitivity: The comparison is case-sensitive, meaning that uppercase and lowercase characters are treated differently.
Additional Notes on Parameters:
- If the parameter is
null, aNullPointerExceptionis thrown. Always ensure that the parameter is notnull. - The
compareTo()method compares strings based on the Unicode value of each character.
Returns
- It returns 0 if both are lexicographically equal.
- It returns positive integer if compared string or object is greater lexicographically.
- It returns negative integer if one of the compared is smaller lexicographically.
Exceptions
The compareTo() method returns 2 exceptions.- ClassCastException, if the object can not be compared then it returns this exception.
- NullPointerException, if the string is null then NullPointerException is thrown.
Java String compareTo() Method Examples
class Main {
public static void main(String[] args) {
// declaring strings to be used in this example for Java string compareTo() method
String str = "Java compareTo() method example";
String str1 = "Java compareTo() method example";
String str2 = "this is Java compareTo() method example";
String str3 = "Java CompareTo() Method Example";
String str4 = "a Java compareTo() method example";
String str5 = new String("Java compareTo() method example");
// comparing the str and str1 strings
System.out.println(str.compareTo(str1));
// comparing the str and str2 strings
System.out.println(str.compareTo(str2));
// comparing the str and str3 strings
System.out.println(str.compareTo(str3));
// comparing the str and str4 strings
System.out.println(str.compareTo(str4));
// comparing the str string and str5 string object
System.out.println(str.compareTo(str5));
}
}
Output
0
-42
74
-23
0
As we know the str and str1 strings are equal lexicographically so it returned 0. While comparing str and str2 it returned negative 42 value because the compared string str is smaller lexicographically so it’s a negative and on the basis of unicode value t char and J char has a difference of 42, so a -42 value is returned. For the rest you can see the results to better understand this method.
Example of an Empty String
public class Main{
public static void main(String args[]){
String str="compareTo()";
// declaring an empty string
String str1="";
String str2="method";
System.out.println(str.compareTo(str1));
System.out.println(str1.compareTo(str2));
}
}
Output
11
-6
Example of IgnoreCase
public class Main{
public static void main(String args[]){
String str="compareTo()";
// declaring the same string with uppercase letters
String str1="COMPARETO()";
System.out.println(str.compareTo(str1));
System.out.println(str.compareToIgnoreCase(str1));
}
}
Output
32
0
The Comparable Interface and Its Role in Natural Ordering
The Comparable interface is a part of the java.lang package and provides a mechanism for defining the natural ordering of objects. By implementing this interface, a class specifies how its instances should be compared using the compareTo() method.
The syntax of the interface is:
public interface Comparable {
int compareTo(T o);
}
Here, T represents the type of objects being compared. Implementing the Comparable interface is commonly done in classes like String, Integer, and Date, which have a natural ordering.
Example: Custom Implementation of Comparable
import java.util.Arrays;
public class Student implements Comparable {
private String name;
private int grade;
public Student(String name, int grade) {
this.name = name;
this.grade = grade;
}
@Override
public int compareTo(Student other) {
return Integer.compare(this.grade, other.grade); // Natural ordering by grade
}
@Override
public String toString() {
return name + ": " + grade;
}
public static void main(String[] args) {
Student[] students = {
new Student("Alice", 85),
new Student("Bob", 92),
new Student("Charlie", 78)
};
Arrays.sort(students); // Uses compareTo() for sorting
System.out.println(Arrays.toString(students));
}
}
Output: [Charlie: 78, Alice: 85, Bob: 92]
In this example, the natural ordering is based on grades, allowing Arrays.sort() to organize the objects accordingly.
Exceptions Related to the Comparable Interface
While working with the compareTo() method and the Comparable interface, there are several exceptions to consider:
NullPointerException:This occurs if you attempt to compare an object withnull. Always check fornullvalues before comparison.ClassCastException:This occurs if objects being compared are not of the same type. For example, attempting to compare anIntegerwith aStringwould throw this exception.
Example: Handling Exceptions
import java.util.ArrayList;
import java.util.Collections;
public class ExceptionExample {
public static void main(String[] args) {
try {
ArrayList Object list = new ArrayList<>();
list.add("Apple");
list.add(42);
Collections.sort((ArrayList) list); // Unsafe casting
} catch (ClassCastException e) {
System.out.println("ClassCastException: Objects are not comparable!");
}
}
} 
It's best practice to ensure type safety and validate objects before performing comparisons.
Relationship Between compareTo() and equals()
To maintain consistency in natural ordering, it is essential to understand the relationship between the compareTo() and equals() methods:
- If
compareTo(obj1, obj2) == 0, thenobj1.equals(obj2)should returntrue. - The reverse is not necessarily true. If
obj1.equals(obj2)istrue,compareTo(obj1, obj2)should return 0, but it doesn't dictate how other aspects are handled.
Failing to maintain this consistency can lead to unpredictable behavior when sorting or comparing objects.
Example of Consistency
public class Product implements Comparable {
private String name;
private int price;
public Product(String name, int price) {
this.name = name;
this.price = price;
}
@Override
public int compareTo(Product other) {
return Integer.compare(this.price, other.price);
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Product product = (Product) obj;
return price == product.price && name.equals(product.name);
}
}
GO TO FULL VERSION