Re: nested generic HashMap problem
Chris Riesbeck wrote:
I've looked at the Java generics tutorial, Langer's FAQ, and similar
online pages, but I'm still don't see what, if anything, I can do to
make the last line (marked with the comment) compile, other than do a
typecast and suppress the unchecked warning. Am I asking the impossible
or missing the obvious?
import java.util.HashMap;
public class Demo<T> {
private Class<T> base;
private Cache cache;
Demo(Class<T> b, Cache c) { base = b; cache = c; }
Class<T> getBaseClass() { return base; }
T get(long id) { return cache.get(this, id); }
}
class Cache {
private HashMap<Class<?>, HashMap<Long, ?>> maps
= new HashMap<Class<?>, HashMap<Long, ?>>();
public <T> T get(Demo<T> demo, long id) {
return getMap(demo).get(id);
}
public <T> void add(Demo<T> demo) {
maps.put(demo.getBaseClass(), new HashMap<Long, T>());
}
private <T> HashMap<Long, T> getMap(Demo<T> demo) {
return maps.get(demo.getBaseClass()); // incompatible types
}
}
No way while you have the wildcards there. Suppressing unchecked warnings
will only expose you to ClassCastException.
Did you also read the free chapter on generics from Josh Bloch's /Effective
Java/ available at java.sun.com?
You only suppress unchecked warnings when you have documentable proof that you
cannot get a ClassCastException, and that documentation needs to be in the
program comments.
As defined, your 'Cache#maps' variable cannot even guarantee that the base
type of the 'Class' key matches the type of the value map's value.
Furthermore, you define all that in terms of concrete classes instead of
interfaces. Oops.
You might have better luck putting an upper bound (e.g., 'Foo') on the type of
'T' and have
public class Cache <Foo>
{
private Map <Class <? extends Foo>, Map <Long, Foo>> maps;
}
or perhaps
public class Cache <Foo>
{
private Map <Class <? extends Foo>, Map <Long, ? extends Foo>> maps;
}
but as long as you're holding disparate types in your so-called "cache" I
don't think you can avoid the risk of ClassCastException.
I could be wrong. Type analysis is tricky.
Whenever I find tricky generics questions like these, I find it pays to really
think very hard about what to assert about the types. Once I figure that out
the generics are a simple reflection of that analysis.
--
Lew