djeikyb djeikyb - 2 years ago 90
Java Question

Cannot convert from List<List> to List<List<?>>

A raw list converts to

just fine. Why can't a list of raw lists convert to a list of

{ // works
List raw = null;
List<?> wild = raw;
{ // Type mismatch: cannot convert from List<List> to List<List<?>>
List<List> raw = null;
List<List<?>> wild = raw;

Backstory (to mitigate the xy problem):

An API I'm using returns
. I happen to know that it is always
. I plan to loop and build my own
, but I was trying to fix (but not suppress) the raw type compiler warning when I write
List<JAXBElement> raw = api();

I tried:

List<JAXBElement<?>> raw = api();
List<JAXBElement<?>> raw = (List<JAXBElement<?>>) api();

but these give the type mismatch error.

Interestingly, this gives no warning or error:

for (JAXBElement<?> e : api()) {
// ...

Answer Source
// #1 (does compile)
List raw = null;
List<?> wild = raw;

// #2 (doesn't compile)
List<List> raw = null;
List<List<?>> wild = raw;

First let's sort out why these are actually unrelated assignments. That is to say, they are defined by different rules.

#1 is called an unchecked conversion:

There is an unchecked conversion from the raw class or interface type (§4.8) G to any parameterized type of the form G<T1,...,Tn>.

Specifically it is a special case of an assignment context just for this scenario:

If, after [other possible conversions] have been applied, the resulting type is a raw type, an unchecked conversion may then be applied.

#2 requires a reference type conversion; however the problem with it is that it is not a widening conversion (which is the kind of reference conversion that would be implicitly allowed without a cast).

Why is that? Well, this is specifically governed by the rules of generic subtyping and more specifically this bullet point:

Given a generic type declaration C<F1,...,Fn> (n > 0), the direct supertypes of the parameterized type C<T1,...,Tn>, where Ti (1 ≤ in) is a type, are all of the following:

  • C<S1,...,Sn>, where Si contains Ti (1 ≤ in).

This refers us to something the JLS calls containment, where to be a valid assignment, the arguments of the left-hand side must contain the arguments of the right-hand side. Containment largely governs generic subtyping since "concrete" generic types are invariant.

You may be familiar with the ideas that:

  • a List<Dog> is not a List<Animal>
  • but a List<Dog> is a List<? extends Animal>.

Well, the latter is true because ? extends Animal contains Dog.

So the question becomes "does a List<?> contain a raw List"? And the answer is no: although List<?> is a subtype of List, this relationship does not hold for type arguments.

There is no special rule that makes it true: List<List<?>> is not a subtype of List<List> for essentially the same reason List<Dog> is not a subtype of List<Animal>.

So because List<List> is not a subtype of List<List<?>>, the assignment is invalid. Similarly, you cannot perform a direct narrowing conversion cast because List<List> is not a supertype of List<List<?>> either.

To make the assignment you can still apply a cast. There are three ways to do it that seem reasonable to me.

// 1. raw type
List<List<?>> list0 = (List) api();

// 2. slightly safer
@SuppressWarnings({"unchecked", "rawtypes"})
List<List<?>> list1 = (List<List<?>>) (List<? extends List>) api();

// 3. added 5/23/16: this version doesn't cause a raw type warning
List<List<?>> list2 = (List<List<?>>) (List<? super List<?>>) api();

(You can substitute JAXBElement for the inner List.)

Your use-case for this casting should be safe because List<List<?>> is a more restrictive type than List<List>.

  • The raw type statement is a widening cast then unchecked assignment. This works because, as shown above, any parameterized type can be converted to its raw type and vice-versa.

  • The slightly safer statement (dubbed so because it loses less type information) is a widening cast then narrowing cast. This works by casting to a common supertype:

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

    The bounded wildcard allows the type arguments to be considered for subtyping via containment.

    And as a side note, in previous revisions of this answer I was hesitant about why List<? extends List> is considered a supertype of List<List<?>>, but this can be proven through the transitive property:

    1. ? extends List contains ? extends List<?> because List is a supertype of List<?>.

    2. ? extends List<?> contains List<?>.

    3. Therefore ? extends List contains List<?>.

    That is, List<? extends List> :> List<? extends List<?>> :> List<List<?>>.

  • The third example (added 5/23/16) works pretty much the same way as the second example, by casting to a common supertype List<? super List<?>>. It's just a little nicer in that since it doesn't use a raw type, we can suppress one less warning.

The non-technical summary here is that the specification implies that there is neither subtype nor supertype relationship between List<List> and List<List<?>>.

Although converting from List<List> to List<List<?>> should be safe, it is not allowed. (It's safe because both are a List that can store any kind of List, but a List<List<?>> imposes more restrictions on how its elements can be used after they are retrieved.)

There is unfortunately no practical reason this fails to compile except that raw types are strange and usage of them is problematic.

Recommended from our users: Dynamic Network Monitoring from WhatsUp Gold from IPSwitch. Free Download