In Java, How do you quicksort an ArrayList of objects in which the sorting field is multiple layers deep?

Question

Basically, I have a Container class called \"Employees\" which has in it an ArrayList. This ArrayList contains \"Employee\" objects, which in turn contain \"EmployeeData\" objec

Answer 1

Peter DeWeese and others have given you very good answers. You can use

Collections.sort(myList, new MyComparator());

to sort myList using a Comparator you have defined. <=== What the heck does that mean?

In Java, if something implements Comparable (java.lang.comparable) then you can define an order for your elements. It seems like you know what Java Generics are, as you used them to declare your ArrayList as being of type < Employee >. This is awesome, because you can store an Employee object into each entry in the ArrayList. So far so good?

However, if you want to sort objects, first you have to define an order. Since objects can have various properties, maybe I want to sort my employees by ear-size. In this case, I simply tell Java that my class implements Comparable. With generics, I have to specify that it implements Comparable< Employee > because I am defining an order for my Employee objects (peons, minions, whatever).

Peter DeWeese mentioned:

 public int compareTo(Employee e)
 {
     return this.getData().getLast().compareTo(e.getData().getLast());
 }

and Jason Goemaat mentioned:

public int compareTo(Employee other)
{
    return Data.Last.compareTo(other.Data.Last);
}

What the heck does this mean? If I say that my class implements Comparable then I need to define a compareTo function. (An interface is a collection of methods that need to be implemented) The function compareTo defines the order of my elements.

From the Comparable< T> spec:

int compareTo(T o)

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

If I am comparing ear sizes, and let's say I want big ears to come first in my list, then I could (re)define compareTo as:

public int compareTo(Employee e)
{
    if (this.earSize > e.earSize) //big ears come first
        return -1;
    if (this.earSize == e.earSize) //equality
        return 0;
    else
        return 1; // if e.earSize > this.earSize then return 1
}

To answer Steve Kuo's question, we put the keyword this in our comparator because when we call the compareTo method

x.compareTo(y); 

the keyword this will refer to x.

You can think of compareTo as being a method of the object x, so when you call x.compareTo(y) you are really saying this.compareTo(y) from within the scope of object x.

We can also look at a String example:

This means that if I want "Medvedev" to come before "Putin" (as 'M' comes before 'P' in the English alphabet) I would have to state that I want compareTo to return -1 when comparing Medvedev to Putin.

String TheMString = "Medvedev";
String ThePString = "Putin";

then the line

TheMString.compareTo(ThePString);

will evaluate to -1.

Now a standard routine such as Collections.sort(list, comparator) will be able to use these values that compareTo returns to figure out the [absolute] order of list. As you may know, sorting is a comparison based operation and we need to know what value is "less than" or "greater than" another value in order to have a meaningful sort.

One big caveat is that if you call compareTo on Strings, it defaults to alphabetical order, so you may simply tell compareTo to return A.compareto(B) and it will make sure the strings are in order.

Normally (well, I should say, in other cases) when redefining the compareTo method, you must explicitly state a neg/zero/pos return value.

I hope that helps.