Java Comparable Interface In Addition To Compareto() Example

Hello, guys, today I am going to beak nearly i of the key concepts inward Java, defining the natural ordering of the objects e.g. lexicographical lodge for String together with numerical lodge for Number classes e.g. Integer, Double, Float etc. The compareTo() method is defined inward the java.lang.Comparable interface. It is used to define the natural ordering of an object e.g. String degree override compareTo() to define the lexicographical lodge for String objects. Integer degree override compareTo() to define the numeric ordering of integer objects. Similarly, y'all tin override compareTo() method yesteryear implementing Comparable interface to define the natural lodge on which y'all desire to lodge your object. For example, an Order should travel ordered yesteryear lodge id so compareTo() must furnish logic for that.

Now, the query comes where does this natural ordering is required? Why exercise y'all need it inward the showtime place? Well, inward existent the world application, y'all are non dealing alongside but i object, y'all bargain alongside a collection of objects. For example, inward an e-commerce arrangement y'all convey millions of orders together with if y'all desire to display them, y'all cannot display inward whatsoever random order, that won't exercise whatsoever benefit. You need to impress or display them inward an lodge which makes sense. The most mutual lodge is known equally the natural lodge e.g. listing of orders ordered yesteryear their OrderId.

The compareTo() method is mainly used inward sorting process. In Java programs, when y'all oft kind a listing of object yesteryear calling Collections.sort(list), they are sorted based upon their natural lodge which is defined by compareTo() method. You should likewise retrieve that compareTo() returns a positive pose out if the electrical current object is greater than given object, a negative pose out if electrical current (this) object is less than given object together with nix if both objects are equal.

One of the subtle item nearly compareTo() is that it must jibe alongside equals() method e.g. if objects are equal alongside equals() together with so their compareTo() must render zero, failing to oblige this dominion tin create problems if y'all shop your objects which uses both equals() together with compareTo() method e.g. TreeSet together with TreeMap.  See Core Java Volume 1 - Fundamentals by Cay S. Horstmann to larn to a greater extent than such details nearly compareTo() method inward Java.

Java compareTo() Example

There are a lot of classes inward Java which implements compareTo() method e.g. String, Integer, Long, Float, Double etc. You tin meet their implementation together with how they travel yesteryear running these examples. For example, let's say, y'all convey a listing of String together with y'all desire to kind them inward increasing order. You don't need to exercise anything, this ordering is defined inward the compareTo() method of java.lang.String degree equally shown below:

public int compareTo(String anotherString) {     int len1 = value.length;     int len2 = anotherString.value.length;     int lim = Math.min(len1, len2);     char v1[] = value;     char v2[] = anotherString.value;      int k = 0;     while (k < lim) {       char c1 = v1[k];       char c2 = v2[k];       if (c1 != c2) {         return c1 - c2;       }       k++;     }     return len1 - len2;   }

This method compares 2 strings lexicographically. The comparing is based on the Unicode value of each grapheme inward the strings. The grapheme sequence represented yesteryear this String object is compared lexicographically to the grapheme sequence represented yesteryear the declaration string.

In lexicographic ordering, If 2 strings are different, together with so either they convey dissimilar characters at closed to index that is a valid index for both strings, or their lengths are different, or both.

All y'all need to exercise is but telephone band the Collections.sort() method to kind the listing of String. This method uses Strategy blueprint pattern together with calls compareTo() method which defines sorting strategy of the object. Every object is costless to override how they compare, which nosotros volition meet inward adjacent section. Btw, hither is a diagram which shows that both String together with wrapper classes implement Comparable interface inward Java:

Java Comparable together with ComapreTo Example

Now, let's how to override compareTo() method for a user object. In this program, we'll create a user defined object called lodge which has fields similar OrderId (a non-negative number), Customer details together with full amount. The natural lodge for this object is yesteryear OrderId e.g. on increasing order, OrderId alongside 1 volition come upward earlier OrderId 2 together with on decreasing order, Order alongside Id 2 volition come upward earlier an object alongside Id 1.

import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collections; import java.util.List;  /*  * Java Program to present compareTo() instance  * together with Comparable instance  */  public class Main {    public static void main(String[] args) {      // let's create dyad of lodge to compare     Order first = new Order(1, "abc", BigDecimal.TEN);     Order 2nd = new Order(2, "xyz", new BigDecimal("10"));     Order 3rd = new Order(3, "kbc", BigDecimal.ONE);      // let's compare showtime together with 2nd order     int result = first.compareTo(second);     if (result > 0) {       System.out.println("first lodge is greater than second");            } else if (result < 0) {       System.out.println("first lodge is less than second");            } else if (result == 0) {       System.out.println("both orders are same");     }      // allow kind the lodge equally per natural lodge defined yesteryear compareTo()     List<Order> listOfOrders = new ArrayList<>();     listOfOrders.add(first);     listOfOrders.add(third);     listOfOrders.add(second);      Collections.sort(listOfOrders);     System.out.println(listOfOrders);    }  }  /*  * H5N1 degree which implements Comparable interface together with overrides compareTo()  * method. Make certain y'all purpose Generic together with define type parameter for Comparable,  * inward this way, y'all don't need to cast Object to Order within compareTo() method  */ class Order implements Comparable<Order> {   private int id;   private String customer;   private BigDecimal total;    public Order(int id, String customer, BigDecimal total) {     this.id = id;     this.customer = customer;     this.total = total;   }    @Override   public int compareTo(Order ord) {     return this.id - ord.id;   }    @Override   public String toString() {     return "OrderId-" + id;   }  }  Output the first lodge is less than 2nd [OrderId-1, OrderId-2, OrderId-3]

You tin meet from the output that showtime lodge is less than 2nd because id of the showtime lodge is 1 together with id of 2nd lodge are 2. So, when y'all kind them inward increasing order, showtime lodge volition come upward earlier 2nd order, which is likewise evident from the 2nd work of output.

Anyway, It's non that y'all are alone express to i order, y'all can, of course, define custom ordering e.g. ordering lodge yesteryear the customer, yesteryear engagement or fifty-fifty yesteryear the full amount, but Comparable is non for that. You need to purpose the Comparator interface and overrides its compare() method to define customized ordering similar to lodge yesteryear clause of SQL. You tin larn to a greater extent than nearly the divergence betwixt Comparator together with Comparable here.


That's all inward this Java Comparable together with compareTo() example. Along alongside equals(), hashcode(), together with compare() methods, compareTo() is likewise i of the fundamentals every Java programmer should know. It's real of import to define the ordering for information object because y'all don't desire them sorted inward whatsoever random order, so brand certain when y'all create an object y'all furnish an implementation for critical methods e.g. equals, hashcode, compare, toString together with compareTo.

Other Java basic tutorials y'all may like

• How to override equals() method inward Java? (example)
• How to override hashcode() method inward Java? (example)
• How to override compare() method inward Java? (example)
• How to override toString() method inward Java? (example)
• How to implement clone() method inward Java? (example)
• How to override clone() alongside a mutable champaign inward Java? (example)
• What is the divergence betwixt Comparable together with Comparator inward Java? (answer)

Further Learning
Complete Java Masterclass
Java Fundamentals: The Java Language
Java In-Depth: Become a Complete Java Engineer!

Share this post