How To Override Compareto Method Inwards Coffee - Illustration Tutorial

compareTo inwards Java is inwards the same league of equals() as well as hashcode() as well as used to implement natural lodge of object, compareTo is slightly dissimilar to compare() method of Comparator interface which is used to implement custom sorting order. I accept seen during java interviews that many Java programmers non able to correctly write or implement equals(), hashCode() and compareTo() method for mutual describe organization objects similar Order or Employee. Simple argue behind this is that they either non sympathize the concept good plenty or doesn't write this materials at all. I volition endeavor to fill upwards that gap inwards this Java tutorial as well as volition run across What is compareTo() method inwards java, how to write compareTo in Java and things to shout upwards patch implementing compareTo in Java.

What is compareTo() method inwards Java

compareTo() method is defined inwards interface java.lang.Comparable as well as it is used to implement natural sorting on java classes. natural sorting agency the the kind lodge which naturally applies on object e.g. lexical lodge for String, numeric lodge for Integer or Sorting employee yesteryear at that spot ID etc. virtually of the coffee pith classes including String as well as Integer implements CompareTo() method as well as furnish natural sorting.

Why exercise you lot require CompareTo()

Comparator as well as Comparable inwards Java. Since nosotros shop coffee objects inwards Collection at that spot are also sure as shooting Set and Map which provides automating sorting when you lot insert chemical division on that e.g. TreeSet as well as TreeMap. to implement sorting you lot require to override either compareTo(Object o) method or Comparable degree or compare(Object o1, Object o2) method of Comparator class. Most of the classes implement Comparable to implement natural order. for instance if you lot are writing Employee object you lot likely desire to implement Comparable interface as well as override compareTo() method to compare electrical current employee alongside other employee based on ID. So essentially you lot require to override compareTo() because you lot require to sort elements inwards ArrayList or whatever other Collection.

How to implement compareTo inwards Java

There are sure as shooting rules as well as of import points to shout upwards patch overriding compareTo method:

1) CompareTo method must render negative number if electrical current object is less than other object, positive number if electrical current object is greater than other object as well as null if both objects are equal to each other.

2) CompareTo must survive inwards consistent alongside equals method e.g. if ii objects are equal via equals() , at that spot compareTo() must render zero otherwise if those objects are stored inwards SortedSet or SortedMap they volition non acquit properly. Since SortedSet or SortedMap use compareTo() to cheque the object if ii unequal object are returned equal yesteryear compareTo those volition non survive added into Set or Map if they are non using external Comparator.  One instance where compareTo is non consistent alongside equals inwards JDK is BigDecimal class. ii BigDecimal number for which compareTo returns zero, equals returns faux every bit clear from next BigDecimal comparing example:

BigDecimal bd1 = new BigDecimal("2.0");
BigDecimal bd2 = new BigDecimal("2.00");
     
System.out.println("comparing BigDecimal using equals: " + bd1.equals(bd2));
System.out.println("comparing BigDecimal using compareTo: " + bd1.compareTo(bd2));

Output:
comparing BigDecimal using equals: false
comparing BigDecimal using compareTo: 0

 

How does it impact BigDecimal ? good if you lot shop these ii BigDecimal inwards HashSet you lot volition terminate upwards alongside duplicates (violation of Set Contract) i.e. ii elements patch if you lot shop them inwards TreeSet you lot volition terminate upwards alongside merely 1 chemical division because HashSet uses equals to cheque duplicates patch TreeSet uses compareTo to cheque duplicates. That's why its suggested to popular off on compareTo consistent alongside equals method inwards java.

3) CompareTo() must throw NullPointerException if electrical current object instruct compared to null object every bit opposed to equals() which render faux on such scenario.

4) Another of import indicate to authorities annotation is don't piece of occupation subtraction for comparing integral values because number of subtraction tin overflow every bit every int functioning inwards Java is modulo 2^32. piece of occupation either Integer.compareTo()  or logical operators for comparison. There is 1 scenario where you lot tin piece of occupation subtraction to cut back clutter as well as meliorate performance. As nosotros know compareTo doesn't assist magnitude, it merely assist whether number is positive or negative. While comparing ii integral fields you lot tin piece of occupation subtraction if you lot are absolutely sure as shooting that both operands are positive integer or to a greater extent than just at that spot dissimilar must survive less than Integer.MAX_VALUE. In this instance at that spot volition survive no overflow as well as your compareTo volition survive concise as well as faster.

5. Use relational operator to compare integral numeric value i.e. < or > but piece of occupation Float.compareTo() or Double.compareTo() to compare floating indicate number every bit relational operator doesn't obey contract of compareTo for floating indicate numbers.

6. CompareTo() method is for comparing therefore order inwards which you lot compare ii object matters. If you lot accept to a greater extent than than 1 meaning plain to compare than ever start comparing from virtually meaning field to to the lowest degree meaning field. hither compareTo is dissimilar alongside equals because inwards instance of equality cheque lodge doesn't matter. similar inwards to a higher house example of compareTo if nosotros don't consider Id as well as compare ii educatee yesteryear its shout as well as historic menstruum than shout should survive outset compare as well as than age, therefore if ii educatee accept same shout 1 that has higher historic menstruum should number inwards greater.

Student john12 = new Student(1001, "John", 12);
Student john13 = new Student(1002, "John", 13);
     
//compareTo volition render -1 every bit historic menstruum of john12 is less than john13
System.out.println("comparing John, 12 as well as John, xiii alongside compareTo :" + john12.compareTo(john13));

Output:
comparing John, 12 as well as John, 13 alongside compareTo :-1

7. Another of import indicate patch comparing String using compareTo is to consider case. merely similar equals() doesn't consider case, compareTo also exercise non consider case, if you lot desire to compare regardless of instance than piece of occupation String.compareToIgnoreCase() every bit nosotros accept used inwards to a higher house example.

Where compareTo() method used inwards Java

---------------------------------------------------

In Java API compareTo() method is used inwards SortedSet e.g. TreeSet and SortedMap e.g. TreeMap for sorting elements on natural lodge if no explicit Comparator is passed to Collections.sort() method e.g.

List stocks = getListOfStocks();
Collections.sort(stocks);

as mentioned before if compareTo is non consistent alongside equals therefore it could gain foreign result. allow took about other instance you lot pose Stock Influenza A virus subtype H5N1 as well as Stock B on StockSet which is a TreeSet. Both Stock Influenza A virus subtype H5N1 as well as Stock B are equal yesteryear equals() method but compareTo render non null values for it which makes that StockB volition also survive landed into TreeSet which was voilation of Set itself because it is non supposed to allow duplicates.

Example of compareTo() inwards Java
--------------------------------------

Let’s run across an instance of how to override compareTo method inwards Java. This method is real similar to equals as well as hashcode, cardinal thing is compareTo should furnish natural ordering e.g. inwards this instance lodge of object based on Student ID.

public class Student implements Comparable {
    private int id;
    private String name;
    private int age;
 
    /*
     *Compare a given Student alongside current(this) object.
     *If electrical current Student id is greater than the received object,
     *then electrical current object is greater than the other.
     */  
    public int compareTo(Student otherStudent) {
       // render this.id - otherStudent.id ; //result of this functioning tin overflow
       return (this.id &lt; otherStudent.id ) ? -1: (this.id &gt; otherStudent.id) ? 1:0 ;

    }
}

here is about other instance of compareTo method inwards Java on which compareTo uses ii meaning plain to compare objects:

public class Student implements Comparable<Student> {
   .....   
    /**
     * Compare a given Student alongside current(this) object.
     * outset compare shout as well as than age
     */
    @Override
    public int compareTo(Student otherStudent) {      
        //compare name
        int nameDiff = name.compareToIgnoreCase(otherStudent.name);
        if(nameDiff != 0){
            return nameDiff;
        }
        //names are equals compare age
        return historic menstruum - otherStudent.age;
    }
 
}

That’s all on implementing compareTo method inwards Java. Please add together whatever other fact which you lot think of import to authorities annotation patch overriding compareTo. In summary compareTo should furnish natural ordering as well as compareTo must survive consistent alongside equals() method inwards Java.

Further Learning
Complete Java Masterclass
How to Set ClassPath for Java inwards Windows
How to Convert String to Date inwards Java alongside Example

How to Set Path for Java inwards Windows XP
What is PolyMorphism inwards Java

What is abstraction inwards Java alongside Example

How to Split String inwards Java alongside Example
How to Solve Java.lang.OutOfMemoryError: Java Heap Space

How to Solve UnSupportedClassVersionError inwards Java

Sumber https://javarevisited.blogspot.com/