How To Override Compareto Method Inwards Coffee - Event Tutorial

compareTo inwards Java is inwards the same league of equals() in addition to hashcode() in addition to used to implement natural guild of object, compareTo is slightly unlike to compare() method of Comparator interface which is used to implement custom sorting order. I convey seen during java interviews that many Java programmers non able to correctly write or implement equals(), hashCode() and compareTo() method for mutual concern objects similar Order or Employee. Simple argue behind this is that they either non sympathise the concept good plenty or doesn't write this materials at all. I volition endeavour to fill upwards that gap inwards this Java tutorial in addition to volition run into What is compareTo() method inwards java, how to write compareTo in Java and things to recall spell implementing compareTo in Java.

What is compareTo() method inwards Java

compareTo() method is defined inwards interface java.lang.Comparable in addition to it is used to implement natural sorting on java classes. natural sorting agency the the form guild which naturally applies on object e.g. lexical guild for String, numeric guild for Integer or Sorting employee past times in that place ID etc. around of the coffee nub classes including String in addition to Integer implements CompareTo() method in addition to render natural sorting.

Why practise yous postulate CompareTo()

Comparator in addition to Comparable inwards Java. Since nosotros shop coffee objects inwards Collection in that place are also sure enough Set and Map which provides automating sorting when yous insert chemical ingredient on that e.g. TreeSet in addition to TreeMap. to implement sorting yous postulate to override either compareTo(Object o) method or Comparable shape or compare(Object o1, Object o2) method of Comparator class. Most of the classes implement Comparable to implement natural order. for representative if yous are writing Employee object yous likely desire to implement Comparable interface in addition to override compareTo() method to compare electrical flow employee amongst other employee based on ID. So essentially yous postulate to override compareTo() because yous postulate to sort elements inwards ArrayList or whatever other Collection.

How to implement compareTo inwards Java

There are sure enough rules in addition to of import points to recall spell overriding compareTo method:

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

2) CompareTo must endure inwards consistent amongst equals method e.g. if 2 objects are equal via equals() , in that place compareTo() must render zero otherwise if those objects are stored inwards SortedSet or SortedMap they volition non deport properly. Since SortedSet or SortedMap use compareTo() to banking venture tally the object if 2 unequal object are returned equal past times compareTo those volition non endure added into Set or Map if they are non using external Comparator.  One representative where compareTo is non consistent amongst equals inwards JDK is BigDecimal class. 2 BigDecimal number for which compareTo returns zero, equals returns simulated 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 touching BigDecimal ? good if yous shop these 2 BigDecimal inwards HashSet yous volition destination upwards amongst duplicates (violation of Set Contract) i.e. 2 elements spell if yous shop them inwards TreeSet yous volition destination upwards amongst simply 1 chemical ingredient because HashSet uses equals to banking venture tally duplicates spell TreeSet uses compareTo to banking venture tally duplicates. That's why its suggested to run along compareTo consistent amongst equals method inwards java.

3) CompareTo() must throw NullPointerException if electrical flow object larn compared to null object every bit opposed to equals() which render simulated on such scenario.

4) Another of import betoken to complaint is don't purpose subtraction for comparing integral values because number of subtraction tin give the axe overflow every bit every int performance inwards Java is modulo 2^32. purpose either Integer.compareTo()  or logical operators for comparison. There is i scenario where yous tin give the axe purpose subtraction to cut back clutter in addition to meliorate performance. As nosotros know compareTo doesn't tending magnitude, it simply tending whether number is positive or negative. While comparing 2 integral fields yous tin give the axe purpose subtraction if yous are absolutely sure enough that both operands are positive integer or to a greater extent than just in that place unlike must endure less than Integer.MAX_VALUE. In this instance in that place volition endure no overflow in addition to your compareTo volition endure concise in addition to faster.

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

6. CompareTo() method is for comparing therefore order inwards which yous compare 2 object matters. If yous convey to a greater extent than than i meaning patch to compare than ever start comparing from around meaning field to to the lowest degree meaning field. hither compareTo is unlike amongst equals because inwards instance of equality banking venture tally guild doesn't matter. similar inwards higher upwards example of compareTo if nosotros don't consider Id in addition to compare 2 pupil past times its shout in addition to historic menstruum than shout should endure start compare in addition to than age, therefore if 2 pupil convey same shout i 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 in addition to John, xiii amongst compareTo :" + john12.compareTo(john13));

Output:
comparing John, 12 in addition to John, 13 amongst compareTo :-1

7. Another of import betoken spell comparing String using compareTo is to consider case. simply similar equals() doesn't consider case, compareTo also practise non consider case, if yous desire to compare regardless of instance than purpose String.compareToIgnoreCase() every bit nosotros convey used inwards higher upwards 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 guild 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 amongst equals therefore it could create foreign result. allow took roughly other representative yous pose Stock Influenza A virus subtype H5N1 in addition to Stock B on StockSet which is a TreeSet. Both Stock Influenza A virus subtype H5N1 in addition to Stock B are equal past times equals() method but compareTo render non null values for it which makes that StockB volition also endure 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 into an representative of how to override compareTo method inwards Java. This method is real similar to equals in addition to hashcode, cardinal thing is compareTo should render natural ordering e.g. inwards this representative guild of object based on Student ID.

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

    }
}

here is roughly other representative of compareTo method inwards Java on which compareTo uses 2 meaning patch to compare objects:

public class Student implements Comparable<Student> {
   .....   
    /**
     * Compare a given Student amongst current(this) object.
     * start compare shout in addition to 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 yous think of import to complaint spell overriding compareTo. In summary compareTo should render natural ordering in addition to compareTo must endure consistent amongst 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 amongst Example

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

What is abstraction inwards Java amongst Example

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

How to Solve UnSupportedClassVersionError inwards Java