> Just trying to learn how Comparator works.
>
> Looking at:
"Thufir" wrote ...
>> Just trying to learn how Comparator works.
>>
>> Looking at:
>
> <snip code/>
>> static final Comparator<Employee> SENIORITY_ORDER =
>> new Comparator<Employee>() {
>> public int compare(Employee e1, Employee e2) {
>> return e2.hireDate().compareTo(e1.hireDate());
>> }
...
>> However, how or where is SENIORITY_ORDER ranking defined? I guess
>> it's in
[quoted text clipped - 3 lines]
>> which returns either a negative, positive or zero. We're only
>> interested in negative results?
> Of course, you should read the Javadocs for the Comparator interface, but in
Hear! Hear!
<http://java.sun.com/javase/6/docs/api/java/util/Comparator.html>
> a nutshell, the compare (a, b) function returns the relative order of the
> two items.
[quoted text clipped - 6 lines]
> Comparable) uses the same definition, but you can prioritize the data as you
> see fit to determine how you want the order.
Example: suppose you have an entity class (simplified):
public class Person
{
private String name;
private Double age;
public void setName( String n ) { name = n; }
public String getName() { return name; }
public void setAge( Double a ) { age = a; }
public Double getAge() { return age; }
}
Sometimes you want to sort by name, sometimes by age, sometimes by first one
then the other.
Here's a sample Comparator for age:
Comparator <Person> personAgeComparator = new Comparator <Person> ()
{
public int compare( Person lef, Person rig )
{
if ( lef == null ) { return (rig == null? 0 : -1); }
if ( rig == null ) { return 1; }
if ( lef.getAge() == null ) { return (rig.getAge() == null? 0 : -1 }
if ( rig.getAge() == null ) { return 1; }
return lef.getAge().compareTo( rig.getAge() );
}
}
A more realistic example would use birthdates, which don't change as
continuously as age does.
A name Comparator would be similar, but use a different implementation of the
compare() method, one based on getName() instead of getAge()
One could easily write a Comparator that sorts by age first, then name (or
vice versa).
If a Comparator were to be widely re-used, you'd consider making it a
top-level class:
class PersonAgeComparator implements Comparator <Person>
{
public int compare( Person lef, Person rig )
{
// etc.
}
}

Signature
Lew