Comment déclarer une carte avec des variables génériques?

J'ai un Map dont les touches sont de type générique Key<T>, et les valeurs sont de type List<T>. Si la clé est une instance de Key<String>, la valeur doit être un List<String>, et la même règle s'applique à toutes les autres paires clé-valeur. J'ai essayé ce qui suit, mais il ne compile pas:

Map<T, List<T>> map;

À l'heure actuelle, je dois le déclarer avec "partielle" génériques:

Map<Object, List> map;

Je sais que c'est mauvais, mais je n'ai actuellement pas de meilleur choix. Est-il possible d'utiliser des génériques dans cette situation?

Mise à JOUR

Peut-être que je n'exprime pas mon problème clairement. Je veux une carte qui est en mesure de:

map.put(new Key<String>(), new ArrayList<String>());
map.put(new Key<Integer>(), new ArrayList<Integer>());

Et le code suivant ne devrait pas compiler:

map.put(new Key<String>(), new ArrayList<Integer>());

La clé et la valeur doit toujours avoir le même type générique, tandis que le type générique peut être tout, et, évidemment, l'extension d'une carte ne répond pas à mes besoins.

l'espace ne doit pas être la question. Il est probable que la manière dont il est utilisé. OP besoin de montrer plus de code à corriger.
Êtes-vous à l'aide des touches de type T, ou les touches de type Key<T>?
Avec votre scénario, vous devez utiliser l'encapsulation pour résoudre votre problème comme Nishant et Geoff les états dans leurs réponses, juste l'adapter à votre propre code.
L'Encapsulation ne fonctionne pas ici, car je n'ai qu'une seule carte. Je ne veux pas déclarer Test<String>, Test<Integer>, etc.

OriginalL'auteur Zhao Yi | 2012-07-16

  1. 7

    Je ne suis pas au courant de toute bibliothèque qui n'est précisément de cela, mais il n'est pas trop difficile à mettre en œuvre vous-même. J'ai fait quelque chose de similaire à quelques reprises dans le passé. Vous ne pouvez pas utiliser la norme d'interface de Carte, mais vous pouvez utiliser une table de hachage de la carte à l'intérieur pour mettre en œuvre votre classe. Pour commencer, il pourrait ressembler à quelque chose comme ceci:

    public class KeyMap {
  public static class Key<T> { }

  private final HashMap<Object,List<?>> values = new HashMap<Object,List<?>>();

  public <T> void put(Key<T> k, List<T> v) {
    values.put(k, v);
  }

  public <T> List<T> get(Key<T> k) {
    return (List<T>)values.get(k);
  }

  public static void main(String[] args) {
    KeyMap a = new KeyMap();
    a.put(new Key<String>(), new ArrayList<String>());
    a.get(new Key<Integer>());
  }
}
    Vous êtes réellement enveloppant mon Map<T, List<T>> map dans une autre classe. Semble qu'une simple carte ne peut pas répondre à mon exigence, et c'est peut-être le dernier choix. Merci!!!!

    OriginalL'auteur Geoff Reedy

  2. 4

    C'est ce que vous voulez:

    public class Test<T> extends HashMap<T, List<T>>
{
}

    Si vous ne voulez pas d'une table de hachage comme la super-classe ensuite de le modifier pour quelle que soit la classe de béton que vous voulez.

    Veuillez voir ma mise à jour.
    J'ai changé ma réponse.
    Mais comment pourrais-je l'utiliser seule Test exemple pour stocker mes données?
    Je ne suis pas entièrement sûr de ce que tu veux dire. Pourriez-vous développer votre question?
    La clé et sa valeur associée doit toujours avoir le même type générique, comme Key<String> --> List<String> et Key<Integer> --> List<Integer>. Avec votre solution, si je déclare un Test<String>, alors je ne vais pas être en mesure de mettre un Key<Integer> --> List<Integer>.

    OriginalL'auteur Brad