compareTo and compare, worked on a scoreboard

The lesson behind it is Implementing Comparable.

A Score class gets a natural order with compareTo, and a second order from a separate class with compare.

This device is not saving progress, so your checks will be gone when you reload.

The 2 orders

A Score holds a player's initials and a number of points.

Both methods answer the same question with the sign of an int.

The natural order

public class Score implements Comparable<Score>
{
    private String initials;
    private int points;

    public Score(String initials, int points)
    {
        this.initials = initials;
        this.points = points;
    }

    public String getInitials()
    {
        return this.initials;
    }

    public int getPoints()
    {
        return this.points;
    }

    @Override
    public int compareTo(Score other)
    {
        int byPoints = Integer.compare(other.points, this.points);
        if (byPoints != 0)
        {
            return byPoints;
        }
        return this.initials.compareTo(other.initials);
    }

    @Override
    public String toString()
    {
        return this.initials + " " + this.points;
    }
}

The sort, and 4 sample comparisons

Arrays.sort(board) calls compareTo on pairs and arranges the array by the signs.

import java.util.Arrays;

// inside main
Score[] board = {
    new Score("JD", 90),
    new Score("AB", 75),
    new Score("KL", 90),
    new Score("ZZ", 75),
    new Score("AA", 100)
};
Arrays.sort(board);
System.out.println(Arrays.toString(board));

[AA 100, JD 90, KL 90, AB 75, ZZ 75]

A second order, from a separate class

A class can have only 1 compareTo. Any other order goes in a separate class that implements Comparator (a comparator). Its method takes both objects as parameters.

import java.util.Comparator;

public class ByInitials implements Comparator<Score>
{
    @Override
    public int compare(Score a, Score b)
    {
        return a.getInitials().compareTo(b.getInitials());
    }
}

Sorting the same 5 scores with new ByInitials() prints:

[AA 100, AB 75, JD 90, KL 90, ZZ 75]

The cases, one call at a time

Drill

4 questions. Work each one on paper before you tap.

Write it out

Not scored. Type it from memory, then compare. The box is scratch space and is not saved.

@Override
public int compareTo(Score other)
{
    int byInitials = this.initials.compareTo(other.initials);
    if (byInitials != 0)
    {
        return byInitials;
    }
    return Integer.compare(other.points, this.points);
}

Your checklist

Tick these when they are true.

• I can say what a negative, a 0 and a positive result mean for compareTo and for compare.
• My second key runs only when the first key ties.
• I can flip an order from smallest first to largest first by swapping the 2 arguments.
• I use Integer.compare for int keys and String's compareTo for text, never subtraction.
• I can write a class that implements Comparator, with the import and the 2-parameter compare.
• I sorted a small array both ways and every line matched what I expected.

Could you write this cold?

Blank file, no notes, 4 hours on a clock, and only the Java API documentation open. Say yes only when that is true. You can take it back at any time.

The compareTo problem in each practice APE (on Student in Practice exams 1 and 2, on Luggage in Practice exam 3) and the StudentComparator problem in Practice exam 2 use these moves.

If a piece of this is shaky

• Implementing Comparable, for the contract and the multi key cascade.
• Order is a sign, if the negative and positive results still feel arbitrary.
• An interface is a promise, if you are not sure what implements buys you.
• Natural order is implements Comparable and the result is a sign only.
• The multi key compareTo body.
• The subtraction trick and why it overflows, then the fix.
• Consistency with equals, for what a result of 0 promises.