Last Updated : 23 Jul, 2025
The Comparable interface in Java is used to define the natural ordering of objects for a user-defined class. It is part of the java.lang package and it provides a compareTo() method to compare instances of the class. A class has to implement a Comparable interface to define its natural ordering.
Example 1: Here, we will use the Comparable interface to sort integers.
Java
import java.util.*;
class Number implements Comparable<Number> {
int v; // Value of the number
// Constructor
public Number(int v) {
this.v = v;
}
// toString() for displaying the number
@Override
public String toString() {
return String.valueOf(v);
}
// compareTo() method to
// define sorting logic
@Override
public int compareTo(Number o) {
// Ascending order
return this.v - o.v;
}
public static void main(String[] args) {
// Create an array of Number objects
Number[] n = { new Number(4), new Number(1),
new Number(7), new Number(2) };
System.out.println("Before Sorting: "
+ Arrays.toString(n));
// Sort the array
Arrays.sort(n);
// Display numbers after sorting
System.out.println("After Sorting: " + Arrays.toString(n));
}
}
Before Sorting: [4, 1, 7, 2] After Sorting: [1, 2, 4, 7]
Explanation: In the above example, the compareTo() method is overridden to define the ascending order logic by comparing the v fields of Number objects. Then the Arrays.sort() method sorts the array by using this logic.
Declaration of Comparable Interfacepublic interface Comparable<T> {
int compareTo(T obj);
}
where, T is the type of object which to be compared.
Example 2: Sorting Pairs with String and Integer Fields
Given an array of Pairs consisting of two fields of type string and integer. Now, we have to sort the array in ascending Lexicographical order and if two strings are the same, sort it based on their integer value.
Java
import java.util.*;
class Pair implements Comparable<Pair> {
String s; // String
int v; // Integer
// Constructor
public Pair(String s, int v) {
this.s = s;
this.v = v;
}
// toString() method for
// displaying the Pair
@Override
public String toString() {
return "(" + s + ", " + v + ")";
}
// compareTo() method for
// comparison logic
@Override
public int compareTo(Pair p) {
// Compare based on the string field
// (lexicographical order)
if (this.s.compareTo(p.s) != 0) {
return this.s.compareTo(p.s);
}
// If strings are the same,
// compare based on the integer value
return this.v - p.v;
}
public static void main(String[] args) {
// Create an array of
// Pair objects
Pair[] p = {
new Pair("abc", 3),
new Pair("a", 4),
new Pair("bc", 5),
new Pair("a", 2)
};
System.out.println("Before Sorting:");
for (Pair p1 : p) {
System.out.println(p1);
}
// Sort the array of pairs
Arrays.sort(p);
System.out.println("\nAfter Sorting:");
for (Pair p1 : p) {
System.out.println(p1);
}
}
}
Before Sorting: (abc, 3) (a, 4) (bc, 5) (a, 2) After Sorting: (a, 2) (a, 4) (abc, 3) (bc, 5)
Note: if two strings are the same then the comparison is done based on the value.
Example 3: Sorting Pairs with First and Last Names
Given an array of Pairs consisting of two strings with first and last names. Now, we have to sort the array in ascending Lexicographical order of the first name and if two strings are the same sort it based on their last name.
Java
import java.util.*;
class Pair implements Comparable<Pair> {
String f; // First name
String l; // Last name
// Constructor
public Pair(String f, String l) {
this.f = f;
this.l = l;
}
// toString() method
// for displaying the Pair
@Override
public String toString() {
return "(" + f + ", " + l + ")";
}
// compareTo method for
// comparison logic
@Override
public int compareTo(Pair p) {
// Compare based on the first name
// (lexicographical order)
if (this.f.compareTo(p.f) != 0) {
return this.f.compareTo(p.f);
}
// If first names are the same,
// compare based on the last name
return this.l.compareTo(p.l);
}
public static void main(String[] args) {
// Create an array of Pair objects
Pair[] p = {
new Pair("raj", "kashup"),
new Pair("rahul", "singh"),
new Pair("reshmi", "dubey"),
};
System.out.println("Before Sorting:");
for (Pair p1 : p) {
System.out.println(p1);
}
// Sort the array of pairs
Arrays.sort(p);
System.out.println("\nAfter Sorting:");
for (Pair p1 : p) {
System.out.println(p1);
}
}
}
Before Sorting: (raj, kashup) (rahul, singh) (reshmi, dubey) After Sorting: (rahul, singh) (raj, kashup) (reshmi, dubey)
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4