What is the difference between compare() and compareTo()?

by

From JavaNotes:

  • a.compareTo(b):
    Comparable interface : Compares values and returns an int which tells if the values compare less than, equal, or greater than.
    If your class objects have a natural order, implement the Comparable<T> interface and define this method. All Java classes that have a natural ordering implement Comparable<T> – Example: String, wrapper classes, BigInteger

  • compare(a, b):
    Comparator interface : Compares values of two objects. This is implemented as part of the Comparator<T> interface, and the typical use is to define one or more small utility classes that implement this, to pass to methods such as sort() or for use by sorting data structures such as TreeMap and TreeSet. You might want to create a Comparator object for the following:

    • Multiple comparisons. To provide several different ways to sort something. For example, you might want to sort a Person class by name, ID, age, height, … You would define a Comparator for each of these to pass to the sort() method.
    • System class To provide comparison methods for classes that you have no control over. For example, you could define a Comparator for Strings that compared them by length.
    • Strategy pattern To implement a Strategy pattern, which is a situation where you want to represent an algorithm as an object that you can pass as a parameter, save in a data structure, etc.

If your class objects have one natural sorting order, you may not need compare().

Summary from http://www.digizol.com/2008/07/java-sorting-comparator-vs-comparable.html

Comparable
A comparable object is capable of comparing itself with another object.

Comparator
A comparator object is capable of comparing two different objects. The class is not comparing its instances, but some other class’s instances.

Use case contexts:

Comparable interface

The equals method and == and != operators test for equality/inequality, but do not provide a way to test for relative values.
Some classes (eg, String and other classes with a natural ordering) implement the Comparable<T> interface, which defines a compareTo() method.
You will want to implement Comparable<T> in your class if you want to use it with Collections.sort() or Arrays.sort() methods.

Defining a Comparator object

You can create Comparators to sort any arbitrary way for any class.
For example, the String class defines the CASE_INSENSITIVE_ORDER comparator.

The difference between the two approaches can be linked to the notion of:
Ordered Collection:

When a Collection is ordered, it means you can iterate in the collection in a specific (not-random) order (a Hashtable is not ordered).

A Collection with a natural order is not just ordered, but sorted. Defining a natural order can be difficult! (as in natural String order).

Another difference, pointed out by HaveAGuess in the comments:

  • Comparable is in the implementation and not visible from the interface, so when you sort you don’t really know what is going to happen.
  • Comparator gives you reassurance that the ordering will be well defined.

More Related Contents:

  1. Extract Substrings using regex Java [closed]
  2. Sequence in java
  3. Difference between wait() and sleep()
  4. How to use Key Bindings instead of Key Listeners
  5. How to redirect multiple types of users to their respective Activities?
  6. Why does Java prohibit static fields in inner classes?
  7. How to find unused/dead code in java projects [closed]
  8. Converting an array of objects to an array of their primitive types
  9. Convert String to Calendar Object in Java
  10. Copy all values from fields in one class to another through reflection
  11. Last row always removed from DefaultTableModel, regardless of index
  12. Why does this subtraction not equal zero?
  13. How to programmatically inject a Java CDI managed bean into a local variable in a (static) method
  14. Add multiple items to an already initialized arraylist in Java
  15. sending variable from one jsp to another jsp
  16. Get method arguments using Spring AOP?
  17. Return data from AsyncTask class
  18. AssertEquals 2 Lists ignore order
  19. Accessing a mapper’s counter from a reducer
  20. How can I create an executable/runnable JAR with dependencies using Maven?
  21. In Java Lambda’s why is getClass() called on a captured variable
  22. iText – add content to existing PDF file
  23. Reading elliptic curve private key from file with BouncyCastle
  24. How to demonstrate race conditions around values that aren’t published properly?
  25. FireStore date query not working as expected
  26. What is the difference between @ApplicationScoped and @Singleton scopes in CDI?
  27. How to inject JPA EntityManager using spring
  28. How do you use a firefox plugin within a selenium webdriver program written in java?
  29. How to synchronize or lock upon variables in Java?
  30. Assigning an array to an ArrayList in Java

Leave a Comment