Вложенный универсальный тип Java

// Dog is a subtype of Animal
class Animal {}
class Dog extends Animal {}

// List<Dog> is a subtype of List<? extends Animal>
List<? extends Animal> a = new ArrayList<Dog>();

// all parameterized Lists are subtypes of List<?>
List<?> b = a;

Итак, применяя эти идеи к вложенному List:

• List<String> является подтипом List<?>, но List<List<String>> не является подтипом List<List<?>>. Как было показано ранее, это предотвращает нарушение безопасности типов путем добавления неправильных элементов в файл List.
• List<List<String>> является подтипом List<? extends List<?>>, поскольку ограниченный подстановочный знак допускает ковариацию. То есть ? extends позволяет учитывать тот факт, что List<String> является подтипом List<?>.

• List<? extends List<?>> на самом деле является общим супертипом:

       List<? extends List<?>>
            ╱          ╲
  List<List<?>>    List<List<String>>
  

Рассматриваемый

1. Map<Integer, List<String>> принимает только List<String> в качестве значения.
2. Map<?, List<?>> принимает любое List в качестве значения.
3. Map<Integer, List<String>> и Map<?, List<?>> — это разные типы с отдельной семантикой.
4. Одно нельзя преобразовать в другое, чтобы мы не могли вносить небезопасные модификации.

5. Map<?, ? extends List<?>> — это общий супертип, который накладывает безопасные ограничения:

           Map<?, ? extends List<?>>
                ╱          ╲
   Map<?, List<?>>     Map<Integer, List<String>>
   

Как работает общий метод

Используя параметр типа в методе, мы можем утверждать, что List имеет конкретный тип.

static <E> void test(Map<?, List<E>> m) {}

Это конкретное объявление требует, чтобы все List в Map имели один и тот же тип элемента. Мы не знаем, что это за тип на самом деле, но мы можем использовать его абстрактно. Это позволяет нам выполнять «слепые» операции.

Например, такое объявление может быть полезно для некоторого накопления:

static <E> List<E> test(Map<?, List<E>> m) {
    List<E> result = new ArrayList<E>();

    for(List<E> value : m.values()) {
        result.addAll(value);
    }

    return result;
}

Мы не можем вызвать put для m, потому что мы больше не знаем, какой у него тип ключа. Однако мы можем манипулировать его значениями, поскольку мы понимаем, что все они List с одним и тем же типом элемента.

Просто для удовольствия

Другой вариант, который не обсуждается в вопросе, - это иметь как ограниченный подстановочный знак, так и общий тип для List:

static <E> void test(Map<?, ? extends List<E>> m) {}

Мы могли бы назвать это чем-то вроде Map<Integer, ArrayList<String>>. Это наиболее разрешительная декларация, если бы нас заботил только тип E.

Мы также можем использовать границы для вложения параметров типа:

static <K, E, L extends List<E>> void(Map<K, L> m) {
    for(K key : m.keySet()) {
        L list = m.get(key);
        for(E element : list) {
            // ...
        }
    }
}

Это разрешает как то, что мы можем ему передать, так и то, как мы можем манипулировать m и всем, что в нем.

Смотрите также

• "Java Generics: Что такое PECS?" для разницы между ? extends и ? super.
• JLS 4.10.2 . Подтипы между типами классов и интерфейсов и JLS 4.5.1. Введите Аргументы параметризованных типов для входа в технические подробности этого ответа.