Re: inverse sort on key?
On 05/08/2008 20:22, nooneinparticular314159@yahoo.com allegedly wrote:
I have an object (say, Car). Car contains some values, one of which
is speed. I want to store lots of cars in some sort of object that
will keep them sorted by speed. Some cars may have the same speed.
The catch is that I want to sort by highest speed, not lowest speed.
If I insert lots of cars into a TreeSet, with the key being the speed,
I get them in increasing order. If there are n cars with the same
speed, I get only one, because the keys are identical. I've been
unable to find an object that would work. I've tried implementing a
compare method in my object, and that doesn't help either. Any ideas?
To summarize, the container object must:
1) Support sorting in inverse order (or another order of my choice)
2) Keep the objects sorted.
Specify a proper Comparator. A TreeSet should do just fine. See example
code below.
3) Support duplicate objects.
I quite certain that's not a problem of order (Comparable/Comparator),
but rather one of _equality_. Do you override equals() in that class?
Does the overridden method specify that two Cars are equal if their
speeds are equal? If yes, there's your problem. If not, I think it's
somewhere in the vicinity.
<code what_about_the_javadoc="shrug">
public class InverseComparator<E>
implements Comparator<E>
{
private Comparator<E>
backingComparator
;
public InverseComparator(){
}
public InverseComparator(Comparator<E> normalorder){
backingComparator = normalorder;
}
public int compare(E o1, E o2) {
if( backingComparator != null ){
return - backingComparator.compare(o1, o2);
}
else{
if( ! (o1 instanceof Comparable) ){
throw new IllegalArgumentException("No normal order
Comparator specified -- Objects must implement Comparable");
}
return - ((Comparable)o1).compareTo(o2);
}
}
public static void main(String[] ss){
List<Car> cars = Arrays.asList( new Car[]{ new Car(2),new
Car(3),new Car(5),new Car(7),new Car(11) } );
List<Car> cars1 = new ArrayList<Car>(cars);
List<Car> cars2 = new ArrayList<Car>(cars);
List<Car> cars3 = new ArrayList<Car>(cars);
List<Car> cars4 = new ArrayList<Car>(cars);
Collections.sort(cars1);
Collections.sort(cars2, new InverseComparator<Car>());
Collections.sort(cars3, new NormalOrderCarComparator());
Collections.sort(cars4, new InverseComparator<Car>(new
NormalOrderCarComparator()));
System.out.println(cars1);
System.out.println();
System.out.println(cars2);
System.out.println();
System.out.println(cars3);
System.out.println();
System.out.println(cars4);
System.out.println();
}
private static class Car
implements Comparable<Car>
{
int speed;
public Car(int speed){
this.speed = speed;
}
public int compareTo(Car o) {
return speed - o.speed;
}
public String toString(){
return "Car[speed=" + speed + "]";
}
}
private static class NormalOrderCarComparator
implements Comparator<Car>
{
public int compare(Car o1, Car o2) {
return o1.speed - o2.speed;
}
}
}
</code>
--
DF.