如何在java Map接口中关联泛型类型参数的值？

Question

I don't think the title of the question will be clear, but the idea is simple.

Suppose I have a Map type variable.

Map<K,V> myMap;

but I want to establish a relation between K and V. for example, I'd like to say that this Map relates Sets of some class to objets of that class. Something like:

Map<Set<T>, T> myMap;

but not for a specific type T. I'd like this Map to accept entries like

(Set<String>, String),
(Set<Integer>, Integer)
...

Is there a possible declaration for myMap that allows me to have this behavior? Please let me know if I'm explaining myself wrongly or if I have a previous conceptual error.

Answer 1

Sadly this is not possible with Java generics. If Java allowed higher order type parameters, then one could have defined Map something like:

public interface Map<V<>> {  // here V<> is my hypothetical syntax for a 
                             // type parameter which is itself generic...
    <K>
    V<K> put(K key, V<K> value);
    ...
}

instead of the actual java.util.Map :

public interface Map<K, V> {
    V put(K key, V value);
    ...
}

You can see that the problem is that K is declared once for the whole class and not for each call to .put() .

Enough fantasizing, so what can you do? I think the best is to create a Map<Set<?>, Object> and wrap it as a private member. Then you are free to create your own put() and get() which take into account the intended "relation" between types:

class SpecialMap {
    private Map<Set<?>, Object> map = ...;

    public <T>
    T put(Set<T> key, T value) {
        return (T) map.put(key, value);
    }

    public <T>
    T get(Set<T> key) {
        return (T) map.get(key);
    }
}

Answer 2

What you are trying to do doesn't seem like a good diea, because each Set<T> is always not equal to another Set<T> even if of the same type - using Sets as keys is more or less useless.

That said, you don't need to define a new class - you can require a method to accept such a map:

public static <T> void process(Map<Set<T>, T> map) {
    for (Map.Entry<Set<T>, T> entry : map) {
        Set<T> key = entry.getKey();
        T value = entry.getValue();
        // do something
    }
}

Answer 3

There is no way with generics to have the compiler verify a different T for each put() call. In other words, you can't have the same map and do:

myMap.put(new HashSet<String>(), "foo");
myMap.put(new HashSet<Integer>(), 1);

If you need this then you may have to store <Object> and do the verification yourself using instanceof or some other hack.

Now, you can definitely do something like:

public class MyMap<T> extends HashMap<Set<T>, T> {
    ...

Then you can do:

MyMap<String> myMap = new MyMap<String>();
Set<String> set = new HashSet<String>();
myMap.put(set, "foo");

Remember that the key has to have a valid hashCode() and equals() methods which might be expensive with a Set .

Answer 4

I don't think it's possible to achieve compile-time checking with Java generics. However it's quite simple at runtime. Just right a short decorator:

public class FancyTypeMapDecorator implements Map<Set<? extends Object>, Object> {

    final Map<Set<? extends Object>, Object> target;

    public FancyTypeMapDecorator(Map<Set<? extends Object>, Object> target) {
        this.target = target;
    }

    @Override
    public Object put(Set<? extends Object> key, Object value) {
        final Class<?> keyElementType = key.iterator().next().getClass();
        final Class<?> valueType = value.getClass();
        if (keyElementType != valueType) {
            throw new IllegalArgumentException(
                "Key element type " + keyElementType + " does not match " + valueType);
        }
        return target.put(key, value);
    }

    @Override
    public void putAll(Map<? extends Set<? extends Object>, ? extends Object> m) {
        for (Entry<? extends Set<? extends Object>, ? extends Object> entry : m.entrySet()) {
            put(entry.getKey(), entry.getValue());
        }
    }

    //remaining methods are simply delegating to target

}

Here's how it works:

final Map<Set<? extends Object>, Object> map =
    new FancyTypeMapDecorator(new HashMap<Set<? extends Object>, Object>());

Set<? extends Object> keyA = Collections.singleton(7);
map.put(keyA, 42);

Set<? extends Object> keyB = Collections.singleton("bogus");
map.put(keyB, 43);

Second put throws an exception.

However both the implementation (and I don't even mean that it will fail for empty Set as a key) and usage/API triggers an alarm bell... Do you really want to deal with such a structure? Maybe you need to rethink your problem? What are you actually trying to achieve?