Comparator for different classes

Question

I have a crazy need to be able to hold a few hundred thousand objects in a Set. These objects can vary from Integers, Doubles to Strings. Normally it seems a HashSet would be the perfect implementation for this, however, this Set is built once and searched through several million times. So it makes sense to have a SortedSet available for this to improve search times. Having different sets for each Class type is not an option.
I've come up with this code, which works fairly well as far as I can tell, but would like your general opinions on how it can be improved. I can't find a failing point, yet, and would like the eyes of many to tell me that I'm wrong - and that it can fail somehow.
public class DifferentObjectComparator implements Comparator, Serializable
     public int compare(Object o1, Object o2)
          if (o1 == null && o2 == null) return 0;
          if (o1 == null && o2 != null) return 1;
          if (o1 != null && o2 == null) return -1;
          if (o1.getClass() == o2.getClass())
               return ((Comparable) o1).compareTo(o2);
          if (o1 instanceof Number && o2 instanceof Number)
               double retVal = ((Number) o1).doubleValue() - ((Number) o2).doubleValue();
               if (retVal < 0) return -1;
               if (retVal > 0) return 1;
               return 0;
          return -1;
}If you know of and/or can think of a better way to do this, please tell. Keep in mind it must use a SortedSet implementation.

Answer 1

cvweiss__ wrote:
After a couple of tweaks and some extensive testing I am now satisfied that the following code fully complies with the specifications given in the javadoc for java.util.Comparator. I'm posting this here for those in the future who have this requirement.
public class DifferentObjectComparator implements Comparator, Serializable
     public int compare(Object o1, Object o2)
          if (o1 == o2) return 0; // good for two nulls or exact same Object
          if (o1 == null && o2 != null) return 1;
          if (o1 != null && o2 == null) return -1;
          if (o1.getClass() == o2.getClass())
               return ((Comparable) o1).compareTo(o2);
          if (o1 instanceof Number && o2 instanceof Number)
               double retVal = ((Number) o1).doubleValue() - ((Number) o2).doubleValue();
               if (retVal < 0) return -1;
               if (retVal > 0) return 1;
               return 0;
          return o1.getClass().getName().compareTo(o2.getClass().getName());
if they ALL implements Comparable, wouldn't the Set be
Set<? extends Comparable> theSet;? In which case, the Comparator could be more elegantly written using similar generics, like
public class MyComparator implements Comparator<Comparable> {
  public int compare(Comparable c1, Comparable c2) {
              if (c1 == c2) return 0;
          if (c1 == null && c2 != null) return 1;
          if (c1 != null && c2 == null) return -1;
          if (c1.getClass() == c2.getClass())
               return c1.compareTo(c2);
          if (c1 instanceof Number && c2 instanceof Number)
               double retVal = ((Number) c1).doubleValue() - ((Number) c2).doubleValue();
               if (retVal < 0) return -1;
               if (retVal > 0) return 1;
               return 0;
          return c1.getClass().getName().compareTo(c2.getClass().getName());   // looks weird to me
}no more ugly castings! (well, except for casting to Number, but that's inherent to the weird spec to begin with)