Hm, sounds interesting. What's about yet another "factory"-like default in Comparator:
Comparator<C> Comparator.make(Class<C> klass) - returns synthetic comparator using C.compareTo iff C implements Comparable<C> - returns null otherwise That will naively instantiate the Comparator, but there is the possibility to reuse e.g. ClassValue to lazily associate the default comparator with the class. -Aleksey. On 08.06.2013, at 19:50, Doug Lea <d...@cs.oswego.edu> wrote: > > Suppose you have two objects, x and y, both of the same > type (x.getClass() == y.getClass()) and both known > to be instanceof Comparable. > > Can you compare them? That is, can you safely call > (Comparable)x).compareTo(y); > > Almost always, the answer is yes, because almost all > Comparable classes are of form "class C implements Comparable<C>" > > But there's nothing about interface Comparable that forces > this to be true. It would be weird but legal if both > are of form, say, "class C implements Comparable<Byte>". > Which means that you cannot compare them to each other. > > There's currently no direct way to check if you have a normal > commutative (bidirectionally applicable) pair of comparables. > > It can be checked using reflection though, using mechanics > that are both messy and slower than they might be if > implemented as a JDK utility method. > > There a few possible API choices for how to do this. > > The most basic is > > boolean isCommutativelyComparable(Class<C?> c); > > returning true if c represents a class form C implements Comparable<C>. > (It would be OK although a little annoying to use if it restricted > argument type to Class<Comparable<?>>.) > > A more general one is: > > Class<?> commutativelyComparableClassFor(Object x) > > that returns a class C such that > (x instanceof C) and (C implements Comparable<C>) > or null if there is no such class. The return type could > be strengthened to Class<Comparable<?>> > > This allows use of the result to match up objects of > subclasses of commutatively comparable classes. > > The most handy form is: > > int compareIfCommutativelyComparable(Comparable x, Comparable y); > > that returns compareTo result if both of same commutatively > comparable type, else 0. > > Maybe this one is *too* handy though. It's not hard to > get the same effect manually given the above methods. > > Does anyone have any thoughts about introducing at > least the first, and possibly the others into the > java.util.Comparables utility class? If so, there would > be a few immediate usages within JDK. > > I'm surprised that this hasn't come up for consideration > before. Or maybe I haven't noticed previous discussions? > > -Doug > > >
