Re: cast to sub-class or extending instance of super or a.n.other

From:

"Mike Schilling" <mscottschilling@hotmail.com>

Newsgroups:

comp.lang.java.programmer

Date:

Sun, 12 Apr 2009 17:36:09 -0700

Message-ID:

<_NvEl.12095$jZ1.4559@flpi144.ffdc.sbc.com>

Arne Vajh?j wrote:

Peter Duniho wrote:

On Sun, 12 Apr 2009 14:16:38 -0700, Arne Vajh?j <arne@vajhoej.dk>
wrote:

Mike Schilling wrote:

Peter Duniho wrote:

For that matter, maybe there _is_ a List implementation out
there
that allows you to provide a Comparator. I haven't noticed one
built into Java if there is, but it wouldn't be surprising if it
exists somewhere.

What job would a Comparator have in a List?

contains and indexOf using a logic different from the
objects equals.

And lastIndexOf(Object o), remove(Object o),
containsAll(Collection<?> c), removeAll(Collection<?> c), and
retainAll(Collection<?> c), not to mention equals(Object o) and
hashCode(). The fact is, as soon as you start introducing the
concept of
comparing two objects (whether just for equality or a complete
ordering), there is also the possibility of wanting to provide
custom logic for that comparison. Given how many different
operations are possible in a List<E>, it seems perfectly logical to
have a List<E> implementation that allows for a custom Comparator.

Maybe overkill in many situations, but hardly unreasonable.

It is one of these things that are not necessary but could be
convenient.

And those things often get low priority in the Java world.

Interestingly, I just noticed that the Comparator<T> interface
doesn't include a hashCode() method. I guess they assume it will
always be used in a context where hash values aren't useful (e.g. a
binary tree implementation of a Map).

That I don't understand.

What should having hashCode() in Comparator<T> provide ?

All objects have hashCode.

Presumably you'd add Comparator.hashCode(object), which would
(logically) have to satisfy

compare(x,y) == 0 -> hashCode(x) == hashCode(y)

Then you could create a HashSet(Comparator c) that hashes the set's
members in a way that's compatible with the comparator's equals()
method.