compareTo() and Collections.sort() Solution For Multiple Column Ordering (Ascending) question

Am somewhat confused with the compareTo() and Collections.sort() behavior.

I am supposed to sort a column in ascending order using compareTo() & Collections.sort().

My criteria is (if the same number occurs than please sort the next available column).

(1) Document Number
(2) Posting Date
(3) Transaction Date
(4) Transaction Reference Number Comparison

Here's the code (which is executed in a calling method) that implements the Collection.sort() method:

public int compareTo(CreditCardTransactionDetail t) {
       int comparison = 0;
       
       int documentNumberComparison = this.getDocumentNumber().compareTo(t.getDocumentNumber());
       if (documentNumberComparison != 0) {
           comparison = documentNumberComparison;
       } 
       else {
           int postingDateComparison = this.getTransactionPostingDate().compareTo(t.getTransactionPostingDate());
           if (postingDateComparison != 0) {
               comparison = postingDateComparison;
           } 
           else {
               int transactionDateComparison = this.getTransactionDate().compareTo(t.getTransactionDate());
               if (transactionDateComparison != 0) {
                   comparison = transactionDateComparison;
               }
               else {
                   int transactionRefNumberComparison = this.getTransactionReferenceNumber().compareTo(t.getTransactionReferenceNumber());
                   LOG.info("\n\n\t\ttransactionRefNumberComparison = " + transactionRefNumberComparison + "\n\n");
                   if (transactionRefNumberComparison != 0) {
                       comparison = transactionRefNumberComparison;
                   }
               }
           }
		return comparison;
}

Question(s):

(1) Am I doing the right thing? When a comparison = 0, it returns as -2. Is this correct behavior because I always thought it to be between -1,0,1.

(2) Should I be using the comparator?

Happy programming...

James Dekker wrote:(1) Am I doing the right thing? When a comparison = 0, it returns as -2. Is this correct behavior because I always thought it to be between -1,0,1.

(2) Should I be using the comparator?

You could check the API documentation for the compareTo() method, if you wanted an answer to question (1). It says

Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

And since -2 is indeed a negative integer, that suggests you aren't doing the wrong thing by returning it.

As for (2): you said you were supposed to use compareTo(). So yes, you're supposed to use a Comparator.

Paul,

Thanks so much for the response!

What I am asking is that if I don't use the comparator() that Collections.sort() is still invoking / calling the compareTo() method in my class, right?

Why is it returning -2?

Peace...

James Dekker wrote:(1) Am I doing the right thing? When a comparison = 0, it returns as -2. Is this correct behavior because I always thought it to be between -1,0,1.

THe return value is never guaranteed to be -1, 0 or 1. All you know is there are three outcomes: smaller than 0, 0 or larger than 0. -1 and 1 are just two specific cases, but -2 will be treated in exactly the same way as -1.

(2) Should I be using the comparator?

You should use compareTo which belongs to Comparable. Comparator's method is called compare. So in this case your class should implement CreditCardTransactionDetail, and Comparator is not needed. (I think Paul mixed up Comparable and Comparator.)
You should only use Comparator if:
1) your class doesn't implement Comparable.
2) you want a different sort order.