"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
>>
>> return e2.hireDate().compareTo(e1.hireDate()); //neg, zero, pos
>>
>> which returns either a negative, positive or zero. We're only
>> interested in negative results?
Matt Humphrey wrote:
> 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.
> If a < b, it should return -1
> if a > b it should return +1
> if a.equals(b) it should 0
>
> It's up to you to define what "<" means by looking at your own data.
The
> compareTo function of Comparables (Strings, Numbers, etc all implement
> 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.
}
}
--
Lew
|
