javagenericsbounded-wildcardunbounded-wildcard

Java nested generic type


How come one must use the generic type Map<?, ? extends List<?>> instead of a simpler Map<?, List<?>> for the following test() method?

public static void main(String[] args) {
    Map<Integer, List<String>> mappy =
        new HashMap<Integer, List<String>>();

    test(mappy);
}

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

// Doesn't compile
// public static void test(Map<?, List<?>> m) {}

Noting that the following works, and that the three methods have the same erased type anyways.

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

Solution

  • Fundamentally, List<List<?>> and List<? extends List<?>> have distinct type arguments.

    It's actually the case that one is a subtype of the other, but first let's learn more about what they mean individually.

    Understanding semantic differences

    Generally speaking, the wildcard ? represents some "missing information". It means "there was a type argument here once, but we don't know what it is anymore". And because we don't know what it is, restrictions are imposed on how we can use anything that refers to that particular type argument.

    For the moment, let's simplify the example by using List instead of Map.

    So to break it down:

    //   ┌ applies to the "outer" List
    //   ▼
    List<? extends List<?>>
    //                  ▲
    //                  └ applies to the "inner" List
    

    The Map works the same way, it just has more type parameters:

    //  ┌ Map K argument
    //  │  ┌ Map V argument
    //  ▼  ▼
    Map<?, ? extends List<?>>
    //                    ▲
    //                    └ List E argument
    

    Why ? extends is necessary

    You may know that "concrete" generic types have invariance, that is, List<Dog> is not a subtype of List<Animal> even if class Dog extends Animal. Instead, the wildcard is how we have covariance, that is, List<Dog> is a subtype of List<? extends Animal>.

    // 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;
    

    So applying these ideas to a nested List:

    In review

    1. Map<Integer, List<String>> accepts only List<String> as a value.
    2. Map<?, List<?>> accepts any List as a value.
    3. Map<Integer, List<String>> and Map<?, List<?>> are distinct types which have separate semantics.
    4. One cannot be converted to the other, to prevent us from doing modifications in an unsafe way.
    5. Map<?, ? extends List<?>> is a shared supertype which imposes safe restrictions:

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

    How the generic method works

    By using a type parameter on the method, we can assert that List has some concrete type.

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

    This particular declaration requires that all Lists in the Map have the same element type. We don't know what that type actually is, but we can use it in an abstract manner. This allows us to perform "blind" operations.

    For example, this kind of declaration might be useful for some kind of accumulation:

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

    We can't call put on m because we don't know what its key type is anymore. However, we can manipulate its values because we understand they are all List with the same element type.

    Just for kicks

    Another option which the question does not discuss is to have both a bounded wildcard and a generic type for the List:

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

    We would be able to call it with something like a Map<Integer, ArrayList<String>>. This is the most permissive declaration, if we only cared about the type of E.

    We can also use bounds to nest type parameters:

    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) {
                // ...
            }
        }
    }
    

    This is both permissive about what we can pass to it, as well as permissive about how we can manipulate m and everything in it.


    See also