# Generics in Map. Type of value abhängig vom key



## Generics (18. Sep 2008)

Hallo zusammen,

Ich habe eine Frage: Gibt es eine Möglichkeit, etwas diesem hier ähnliches zu konstruieren?

Map<Class<T>, Vector<T>>

Das heißt ich möchte die Klasse als Key verwenden und dann einen Vector mit Elementen der entsprechenden Klasse zurückbekommen.

Vielen Dank für die Hilfe.


----------



## Gast (18. Sep 2008)

so

```
class SomeClass<T> {

Map<Class<T>, List<T> map = ...

}
```


----------



## Generics (19. Sep 2008)

ne, das war nicht, was ich meinte. Bei der Lösung bekomme ich nur ein T. Aber das T im Value soll abhängig vom T im Key sein.

Sorry, wenn es nicht verständlich war.


----------



## Landei (19. Sep 2008)

Ich hab mal sowas geschrieben, ist dann aber keine Standard-Map mehr:


```
/**
 * A specialized key class for DependentMap. It wraps a "real" key class and the expected result type.
 */
public class DependentKey<K,T>  {

  private final K key;
  private final Class<T> clazz;

  public DependentKey(K key, Class<T> clazz) {
    this.key = key;
    this.clazz = clazz;
  }

  @Override public final boolean equals(Object o) {
    if (o instanceof DependentKey) {
      DependentKey<?,?> oKey = (DependentKey<?,?>) o;
      return key.equals(oKey.key) && clazz.equals(oKey.clazz) && this.getClass().equals(oKey.getClass());
    } else {
      return false;
    }
  }

  @Override public final int hashCode() {
    return key.hashCode() + 37 * clazz.hashCode() + 101 * this.getClass().hashCode();
  }

  @Override public String toString() {
    return String.format("key(%s)", key.toString());
  }
}
```


```
import java.util.HashMap;
import java.util.Map;

/**
 * A map-like class, that can store objects of different types in a typesafe way.
 * In order to do this, the key has to be a subclass of DependentKey.
 * The interface is minimal, but could be extended easily.
 */
public class DependentMap {

  private Map<DependentKey<?,?>, Object> map = new HashMap<DependentKey<?,?>, Object>();

  public <T> void put(DependentKey<?,T> key, T value) {
      map.put(key, value);
  }

  public boolean containsKey(DependentKey<?,?> key) {
    return map.containsKey(key);
  }

  public <T> T get(DependentKey<?,T> key) {
    return (T) map.get(key);
  }

}
```


----------

