Quelles sont les raisons pour lesquelles Map.get (clé d'objet) n'est pas (entièrement) générique

Quelles sont les raisons de la décision de ne pas avoir de méthode get entièrement générique dans l'interface de java.util.Map<K, V>.

Pour clarifier la question, la signature de la méthode est

V get(Object key)

au lieu de

V get(K key)

et je me demande pourquoi (même chose pour remove, containsKey, containsValue).

Comme mentionné par d'autres, la raison pour laquelle get(), etc. n'est pas générique car la clé de l'entrée que vous récupérez ne doit pas nécessairement être du même type que l'objet auquel vous passez get(); la spécification de la méthode exige seulement qu'elles soient égales. Cela découle de la façon dont la equals()méthode prend un objet en paramètre, et pas seulement du même type que l'objet.

Bien qu'il puisse être généralement vrai que de nombreuses classes se sont equals()définies de sorte que ses objets ne peuvent être égaux qu'aux objets de sa propre classe, il existe de nombreux endroits en Java où ce n'est pas le cas. Par exemple, la spécification de List.equals()indique que deux objets List sont égaux s'ils sont tous deux Lists et ont le même contenu, même s'il s'agit d'implémentations différentes de List. Donc, pour revenir à l'exemple de cette question, selon la spécification de la méthode, il est possible d'avoir un Map<ArrayList, Something>et pour moi d'appeler get()avec un LinkedListargument as, et il devrait récupérer la clé qui est une liste avec le même contenu. Cela ne serait pas possible s'il get()était générique et restreignait son type d'argument.

Un formidable codeur Java chez Google, Kevin Bourrillion, a écrit à propos de ce problème dans un article de blog il y a quelque temps (certes dans le contexte de Setau lieu de Map). La phrase la plus pertinente:

De manière uniforme, les méthodes du Java Collections Framework (et de la Google Collections Library également) ne restreignent jamais les types de leurs paramètres, sauf lorsque cela est nécessaire pour empêcher la collection de se casser.

Je ne suis pas entièrement sûr d'être d'accord avec cela en tant que principe - .NET semble bien exiger le bon type de clé, par exemple - mais cela vaut la peine de suivre le raisonnement dans le blog. (Après avoir mentionné .NET, il vaut la peine d'expliquer qu'une partie de la raison pour laquelle ce n'est pas un problème dans .NET est qu'il y a le plus gros problème dans .NET de variance plus limitée ...)

Le contrat s'exprime ainsi:

Plus formellement, si cette mappe contient un mappage d'une clé k à une valeur v telle que (clé == null? K == null: key.equals (k) ), alors cette méthode renvoie v; sinon, elle renvoie null. (Il peut y avoir au plus un tel mappage.)

(mon accent)

et en tant que tel, une recherche de clé réussie dépend de l'implémentation de la clé d'entrée de la méthode d'égalité. Cela ne dépend pas nécessairement de la classe de k.

C'est une application de la loi de Postel, "soyez conservateur dans ce que vous faites, libéral dans ce que vous acceptez des autres".

Des contrôles d'égalité peuvent être effectués quel que soit le type; la equalsméthode est définie sur la Objectclasse et accepte any Objectcomme paramètre. Il est donc logique que l'équivalence des clés et les opérations basées sur l'équivalence des clés acceptent n'importe quel Objecttype.

Lorsqu'une carte renvoie des valeurs clés, elle conserve autant d'informations de type que possible, en utilisant le paramètre type.

Je pense que cette section du didacticiel sur les génériques explique la situation (je souligne):

"Vous devez vous assurer que l'API générique n'est pas indûment restrictive; elle doit continuer à prendre en charge le contrat d'origine de l'API. Considérez à nouveau quelques exemples de java.util.Collection. L'API pré-générique ressemble à:

interface Collection { 
  public boolean containsAll(Collection c);
  ...
}

Une tentative naïve de le générer est:

interface Collection<E> { 
  public boolean containsAll(Collection<E> c);
  ...
}

Bien que ce type soit certainement sûr, il ne respecte pas le contrat d'origine de l'API. La méthode containsAll () fonctionne avec tout type de collection entrante. Il ne réussira que si la collection entrante ne contient vraiment que des instances de E, mais:

• Le type statique de la collection entrante peut différer, peut-être parce que l'appelant ne connaît pas le type précis de la collection transmise, ou peut-être parce qu'il s'agit d'une collection <S>, où S est un sous-type de E.
• Il est parfaitement légitime d'appeler containsAll () avec une collection d'un type différent. La routine devrait fonctionner et retourner fausse. "

La raison en est que le confinement est déterminé par equalset hashCodequelles sont les méthodes activées Objectet les deux prennent un Objectparamètre. Il s'agissait d'un premier défaut de conception dans les bibliothèques standard de Java. Couplé aux limitations du système de type Java, il oblige tout ce qui s'appuie sur equals et hashCode à prendre Object.

La seule façon d'avoir des tables de hachage typées et l' égalité en Java est à éviter Object.equalset Object.hashCodeet utiliser un substitut générique. Java fonctionnel est fourni avec des classes de type dans ce but: Hash<A>et Equal<A>. Un wrapper pour HashMap<K, V>est fourni qui prend Hash<K>et Equal<K>dans son constructeur. Ces classes getet containsméthodes prennent donc un argument générique de type K.

Exemple:

HashMap<String, Integer> h =
  new HashMap<String, Integer>(Equal.stringEqual, Hash.stringHash);

h.add("one", 1);

h.get("one"); // All good

h.get(Integer.valueOf(1)); // Compiler error

Compatibilité.

Avant que les génériques ne soient disponibles, il y avait juste get (Object o).

S'ils avaient changé cette méthode pour obtenir (<K> o), cela aurait potentiellement forcé une maintenance massive du code sur les utilisateurs java juste pour que le code de travail soit à nouveau compilé.

Ils auraient pu introduire une méthode supplémentaire , par exemple get_checked (<K> o) et déconseiller l'ancienne méthode get () afin qu'il y ait un chemin de transition plus doux. Mais pour une raison quelconque, cela n'a pas été fait. (La situation dans laquelle nous nous trouvons actuellement est que vous devez installer des outils tels que findBugs pour vérifier la compatibilité des types entre l'argument get () et le type de clé déclaré <K> de la carte.)

Les arguments relatifs à la sémantique de .equals () sont faux, je pense. (Techniquement, ils sont corrects, mais je pense toujours qu'ils sont faux. Aucun concepteur sensé ne rendra jamais o1.equals (o2) vrai si o1 et o2 n'ont pas de superclasse commune.)

Il y a une raison de plus, cela ne peut pas être fait techniquement, car cela casse la carte.

Java a une construction générique polymorphe comme <? extends SomeClass>. Une telle référence marquée peut pointer vers un type signé avec <AnySubclassOfSomeClass>. Mais générique polymorphe rend cette référence en lecture seule . Le compilateur vous permet d'utiliser des types génériques uniquement comme type de méthode de retour (comme les simples getters), mais bloque l'utilisation de méthodes où le type générique est un argument (comme les setters ordinaires). Cela signifie que si vous écrivez Map<? extends KeyType, ValueType>, le compilateur ne vous permet pas d'appeler la méthode get(<? extends KeyType>)et la carte sera inutile. La seule solution est de rendre cette méthode pas générique: get(Object).

Rétrocompatibilité, je suppose. Map(ou HashMap) doit encore prendre en charge get(Object).

Je regardais cela et je me demandais pourquoi ils l'avaient fait de cette façon. Je ne pense pas que l'une des réponses existantes explique pourquoi ils ne pouvaient pas simplement faire en sorte que la nouvelle interface générique n'accepte que le type approprié pour la clé. La vraie raison est que même s'ils ont introduit des génériques, ils n'ont PAS créé une nouvelle interface. L'interface de la carte est la même ancienne carte non générique qu'elle sert simplement de version générique et non générique. De cette façon, si vous avez une méthode qui accepte une carte non générique, vous pouvez la transmettre Map<String, Customer>et cela fonctionnerait toujours. Dans le même temps, le contrat pour get accepte Object, la nouvelle interface devrait donc également prendre en charge ce contrat.

À mon avis, ils auraient dû ajouter une nouvelle interface et les implémenter à la fois sur la collection existante, mais ils ont décidé en faveur d'interfaces compatibles même si cela signifie une conception pire pour la méthode get. Notez que les collections elles-mêmes seraient compatibles avec les méthodes existantes, seules les interfaces ne le seraient pas.

Nous effectuons un gros refactoring en ce moment et nous manquions ce get () fortement typé pour vérifier que nous n'avons pas manqué un get () avec l'ancien type.

Mais j'ai trouvé une astuce de contournement / laid pour la vérification du temps de compilation: créer une interface de carte avec get fortement tapé, containsKey, supprimer ... et le mettre dans le package java.util de votre projet.

Vous obtiendrez des erreurs de compilation juste en appelant get (), ... avec des types incorrects, tout le reste semble correct pour le compilateur (au moins à l'intérieur de l'éclipse kepler).

N'oubliez pas de supprimer cette interface après vérification de votre build car ce n'est pas ce que vous voulez en runtime.