Génériques Java (Notes)

Avoir une liste dans la valeur de la carte

demande: La valeur de Map est List, et l'objet géré par cette List a une relation de «Child extend Parent». Ensuite, il y a une instance de chaque List , et je souhaite traiter les objets de la List en tant que parents.

problème

Les génériques ne sont pas covariants, vous ne pouvez donc pas:

Map<Key, List<Parent>> map1;
Map<Key, List<Child>> map2;
list1 = list2;  //Erreur de compilation ici

Par conséquent, nous utilisons des caractères génériques. Cependant, ce qui suit est également NG

Map<Key, List<? extends Parent>> map1;
Map<Key, List<Child>> map2;
list1 = list2; //Erreur de compilation ici

c'est,

List<? extends Parent> list1;
List<Child> list2;
list1 = list2;

Je pouvais le faire, mais je pensais que c'était étrange. Et ce qui suit est la bonne réponse

Map<Key, ? extends List<? extends Parent>> map1;
Map<Key, List<Child>> map2;
map1 = map2;

Comme vous pouvez le voir, j'ai dû utiliser le joker deux fois. Je l'ai utilisé pour définir une méthode et l'exécuter.

  List<Integer> ilist = new ArrayList<Integer>();
  ilist.add(1);
  ilist.add(2);
  ilist.add(3);			
		
  Map<String, List<Integer>> imap = new HashMap<String, List<Integer>>();
  imap.put("1", ilist);
  doit(imap);

  public void doit(Map<String, ? extends List<? extends Number>> inmap) {
      for (String key : inmap.keySet()) {
          System.out.println("key = " + key);
          List<? extends Number> list = inmap.get(key);
          for (Number n : list) {
              System.out.println(n);
          }
      } 
  }

prime:

Une méthode qui retourne une carte avec List <Parent> comme valeur de List <Child>

Partie 1

public <V, K extends T, T> Map<V, List<? extends T>> convert(Map<V, List<K>> srcMap) {
    Map<V, List<? extends T>> dstMap = new HashMap<V, List<? extends T>>();
    for (V key : srcMap.keySet()) {
        dstMap.put(key, srcMap.get(key));
    }
    return dstMap;
}

Partie 2

public <V, K extends T, T> Map<V, List<T>> toUpper(Map<V, List<K>> srcMap) {
    Map<V, List<T>> dstMap = new HashMap<V, List<T>>();
        for (V key : srcMap.keySet()) {
	    List<T> tlist = new ArrayList<T>();
	    for (K val : srcMap.get(key)) {
		tlist.add(val);
	    }
	    dstMap.put(key, tlist);
	}
	return dstMap;
}

Le "n ° 2" est probablement meilleur. La raison est que le type de retour est «Map <V, List >». Selon Effective Java, il n'est pas bon de rendre cette méthode consciente des caractères génériques du côté exécution (par exemple, List <? Etend T>) comme dans la "Partie 1" (probablement ...).

Veuillez signaler toute erreur.