We introduced the notion of a Comparator in Java, which is
used to specify the sort order of a particular class. Let's start with an example to sort Strings
by their length. We thus want to write a `Comparator` that compares `String`s. So the
general format of our Comparator will be as follows:

public class StringLengthComparatorimplements Comparator<String>{ publicint compare(String o1, String o2){ return ... } }

Now, we just need to make the `compare()` return method return an appropriate value to
indicate the ordering. Effectively, the logic of this method should be `o1.compareTo(o2)`.
That is– as discussed when we reviewed `sorting_comparable_compareto.shtml` the `compareTo()`
method– it should return:

- a
**negative**number if (and only if)**o1 comes before o2**; - a
**positive**number if (and only if)**o1 comes after o2**; - else 0.

So a simple implementation would be^{1}:

public class StringLengthComparator implements Comparator<String> { public int compare(String o1, String o2) { if (o1.length() < o2.length()) { return -1; } else if (o1.length() > o2.length()) { return 1; } else { return 0; } } }

Now, armed with our `Comparator` and some vital string data that we need ordering by length:

String[] strs = {"boxer shorts", "grundies", "boxers", "elasticated Y-fronts", "underpants", "briefs"};

we can sort our string data by length with a simple call to `Arrays.sort()`, this time
passing in an instance of our parameter:

// SortArrays.sort(strs, new StringLengthComparator());// Print the results for (String s : strs) System.out.println(s);

And lo and behold, our garments are sorted in correct lengthwise order:

boxers briefs grundies underpants boxer shorts elasticated Y-fronts

Note that, as discussed in our section on the Java sort algorithm,
the sort is **stable**. That is, strings with the same length are guaranteed not to be reversed,
and so our boxers correctly precede our briefs.

1. Some programmers prefer the more succinct version
`return o1.length() < o2.length() ? -1 : (o1.length() > o2.length() ? 1 : 0);`.
It is also presumably safe to use a subtraction–
on 32-bit architecture at least, it's impossible to have Java Strings long enough
to overflow when doing the subtraction!