为什么compareTo方法在排序对象数组时这么慢

Question

I have an array of Entry objects (its part of a solution to create a basic phone directory) - each Entry object containing three fields (which is the data of the phone directory) public String surname; public String initial; public String number; public String surname; public String initial; public String number;

Initially, when adding these to an array (I know an array is NOT a good choice of data structure for something like phone directory, but it was in the specification), after the addition of each entry, it was sorted - the idea being that as the java library sort uses a hybrid Timsort which looks for runs of already sorted data, it would be nearly as fast, and a lot simpler, than inserting the entry into the correct location and than directly inserting the new Entry into the correct location.

The sort method ran as follows

protected void sort() {

    /*
     * Uses comparator because else it fails to sort the null values to the end of the array, and
     * throws null pointer exception instead
     */

    Arrays.sort(this.directory, new Comparator<Entry>() {
        public int compare(Entry entry1, Entry entry2) {
            if (entry1 == null) { // if entries are null will sort to back of
                                // array
                return 1;
            }

            if (entry2 == null) {
                return -1;
            }

            return entry1.surname.compareTo(entry2.surname); //NB this line
        }

    });
}

However, it was pointed out to me that, interacting directly with the fields of another object was bad style (which makes sense!). and so the line marked above was replaced with return entry1.surname.compareTo(entry2.surname);

This means it uses the compareTo method from the entry class. However - for some reason which I don't understand - this slows it down MASSIVELY. It goes from being able to add 3000 entries in a second to taking over 30 seconds - considering the compareTo method below, WHY does it take so long?

    @Override
public int compareTo(Entry o) {

    if (this.getClass() == null) {
        return -1;
    }

    if (o == null) {
        return 1;
    }

    if (this.surname.equalsIgnoreCase(o.surname)) {
        return this.initial.compareToIgnoreCase(o.initial);
    }

    return this.surname.compareToIgnoreCase(o.surname);

}

Answer 1

Your tie resolution logic is inverted: instead of comparing surnames for equality upfront, compare them with compareToIgnoreCase first, and check the result for zero. Otherwise, you are effectively doing the comparison twice:

int res = this.surname.compareToIgnoreCase(o.surname);
return res != 0 ? res : this.initial.compareToIgnoreCase(o.initial);

Assuming a small number of ties, this should speed up your comparisons about twofold.

In addition, your code has other inefficiencies: for example, it is pointless to null check the result of this.getClass() , because it is never null .