Java Generics (Hinweise)

Haben Sie eine Liste im Wert von Map

Anfrage: Der Wert von Map ist List, und das von dieser Liste verwaltete Objekt hat die Beziehung "Child erweitert Parent". Dann gibt es eine Instanz jeder Liste , und ich möchte die Objekte in der Liste als Eltern verarbeiten.

Problem

Generika sind nicht kovariant, daher können Sie nicht:

Map<Key, List<Parent>> map1;
Map<Key, List<Child>> map2;
list1 = list2;  //Kompilierungsfehler hier

Daher verwenden wir Platzhalter. Das Folgende ist jedoch auch NG

Map<Key, List<? extends Parent>> map1;
Map<Key, List<Child>> map2;
list1 = list2; //Kompilierungsfehler hier

das ist,

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

Ich konnte es schaffen, aber ich fand es seltsam. Und das Folgende ist die richtige Antwort

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

Wie Sie sehen, musste ich den Platzhalter zweimal verwenden. Ich habe dies verwendet, um eine Methode zu definieren und auszuführen.

  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);
          }
      } 
  }

Bonus:

Eine Methode, die eine Map mit "List " als Wert aus "List " zurückgibt

Teil 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;
}

Teil 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;
}

Wahrscheinlich ist "Nr. 2" besser. Der Grund ist, dass der Rückgabetyp "Map <V, List >" ist. Laut Effective Java ist es nicht gut, diese Methode auf Platzhalter auf der Ausführungsseite (z. B. "List <? Extends T>") wie in "Teil 1" (wahrscheinlich ...) aufmerksam zu machen.

Bitte weisen Sie auf Fehler hin.