Using generic parameters with static compareObject method

Question

I'd like to remove all "unchecked" warnings from this general utility method (part of a larger class with a number of similar methods). In a pinch, I can use @SuppressWarnings("unchecked") but I'm wondering if I can use generics properly to avoid the warning.

The method is intended to be allow callers to compare two objects by passing through to compareTo, with the exception that if the object is a strings it does it in a case insensitive manner.

public static int compareObject(Comparable o1, Comparable o2)
{
    if ((o1 instanceof String) && (o2 instanceof String))
        return ((String) o1).toUpperCase().compareTo(((String) o2).toUpperCase());
    else
        return o1.compareTo(o2);
}

This was my first (incorrect) attempt at a solution. The parameters work fine, but the line o1.compareTo(o2) has a compile error "The method compareTo(capture#15-of ?) in the type Comparable is not applicable for the arguments (Comparable".

public static int compareObject(Comparable<?> o1, Comparable<?> o2)
{
    if ((o1 instanceof String) && (o2 instanceof String))
        return ((String) o1).toUpperCase().compareTo(((String) o2).toUpperCase());
    else
        return o1.compareTo(o2);
}

Any suggestions?

Answer 1

Did you test the following?

public static <T> int compareObject(Comparable<T> o1, Comparable<T> o2)
{
    if ((o1 instanceof String) && (o2 instanceof String))
        return ((String) o1).toUpperCase().compareTo(((String) o2).toUpperCase());
    else
        return o1.compareTo(o2);
}

I think it should work correctly.

Answer 2

I just tried this:

public static <T extends Comparable> int compareObject(T o1, T o2) {
    if ((o1 instanceof String) && (o2 instanceof String))
        return ((String) o1).toUpperCase().compareTo(((String) o2).toUpperCase());
    else
        return o1.compareTo(o2);
}

It compiles, but gives a unchecked cast warning on the compareTo() call.
I tried changing it to

public static <T extends Comparable<T>> int compareObject(T o1, T o2) {

and the String checks failed to compile ("inconvertible types: found: T, required: String"). I think this must be close, though.

---

EDIT: As pointed out in the comments, this is a bug in javac. The second form is indeed correct, but will not compile currently. Crazy as it may look, this is the code that works with no warnings:

public static <T extends Comparable<T>> int compareObject(T o1, T o2) {
    if (((Object) o1 instanceof String) && ((Object) o2 instanceof String))
        return ((String) (Object)o1).toUpperCase().compareTo(((String) (Object)o2).toUpperCase());
    else
        return o1.compareTo(o2);
}

As you can see, the only difference is all the redundant casts to Object.

Answer 3

Here's what you are looking for:

public static <T extends Comparable<T>> int compareObject(T o1, T o2) {
 if ((o1 instanceof String) && (o2 instanceof String))
  return ((String) o1).toUpperCase().compareTo(((String) o2).toUpperCase());
 else
  return o1.compareTo(o2);
}

Answer 4

I hope you are aware that many of the approaches here do change the semantics of the method. With the original method you could compare objects of different types if they allow this, but with

public static <T extends Comparable<T>> int compareObject(T o1, T o2)

you cannot do this comparison anymore. A variant that allows this would be

    public static int compareObject2(Comparable<Object> o1, Comparable<Object> o2) {
    if (((Object) o1 instanceof String) && ((Object) o2 instanceof String))
        return ((String) (Object)o1).toUpperCase().compareTo(((String) (Object)o2).toUpperCase());
    else
        return o1.compareTo(o2);
}

(I inserted the workaround for the mentioned javac bug.) But this does not enhance type safety or anything, so in this case it is probably better to use the more understandable non generic method and live with a @SuppressWarnings("unchecked"). There is such a thing as overuse of generics.

Answer 5

What about the following:

  public static <T extends Comparable<T>> int compareObjects(T o1, T o2)
  {
    return o1.compareTo(o2);
  }

  public static int compareObjects(String o1, String o2)
  {
    return o1.compareToIgnoreCase(o2);
  }

The drawback is that when call compareObjects() with Objects that happen to be Strings, the compiler will bind your call to the first function, and you'll end up with the case-sensitive comparison.