As Appendix B indicates, this has nothing to do with multiple wildcards, but rather, misunderstanding what List<List<?>>
really means.
Let’s first remind ourselves what it means that Java generics is invariant:
- An
Integer
is aNumber
- A
List<Integer>
is NOT aList<Number>
- A
List<Integer>
IS aList<? extends Number>
We now simply apply the same argument to our nested list situation (see appendix for more details):
- A
List<String>
is (captureable by) aList<?>
- A
List<List<String>>
is NOT (captureable by) aList<List<?>>
- A
List<List<String>>
IS (captureable by) aList<? extends List<?>>
With this understanding, all of the snippets in the question can be explained. The confusion arises in (falsely) believing that a type like List<List<?>>
can capture types like List<List<String>>
, List<List<Integer>>
, etc. This is NOT true.
That is, a List<List<?>>
:
- is NOT a list whose elements are lists of some one unknown type.
- … that would be a
List<? extends List<?>>
- … that would be a
- Instead, it’s a list whose elements are lists of ANY type.
Snippets
Here’s a snippet to illustrate the above points:
List<List<?>> lolAny = new ArrayList<List<?>>();
lolAny.add(new ArrayList<Integer>());
lolAny.add(new ArrayList<String>());
// lolAny = new ArrayList<List<String>>(); // DOES NOT COMPILE!!
List<? extends List<?>> lolSome;
lolSome = new ArrayList<List<String>>();
lolSome = new ArrayList<List<Integer>>();
More snippets
Here’s yet another example with bounded nested wildcard:
List<List<? extends Number>> lolAnyNum = new ArrayList<List<? extends Number>>();
lolAnyNum.add(new ArrayList<Integer>());
lolAnyNum.add(new ArrayList<Float>());
// lolAnyNum.add(new ArrayList<String>()); // DOES NOT COMPILE!!
// lolAnyNum = new ArrayList<List<Integer>>(); // DOES NOT COMPILE!!
List<? extends List<? extends Number>> lolSomeNum;
lolSomeNum = new ArrayList<List<Integer>>();
lolSomeNum = new ArrayList<List<Float>>();
// lolSomeNum = new ArrayList<List<String>>(); // DOES NOT COMPILE!!
Back to the question
To go back to the snippets in the question, the following behaves as expected (as seen on ideone.com):
public class LOLUnknowns1d {
static void nowDefinitelyIllegal(List<? extends List<?>> lol, List<?> list) {
lol.add(list); // DOES NOT COMPILE!!!
// The method add(capture#1-of ? extends List<?>) in the
// type List<capture#1-of ? extends List<?>> is not
// applicable for the arguments (List<capture#3-of ?>)
}
public static void main(String[] args) {
List<Object> list = null;
List<List<String>> lolString = null;
List<List<Integer>> lolInteger = null;
// these casts are valid
nowDefinitelyIllegal(lolString, list);
nowDefinitelyIllegal(lolInteger, list);
}
}
lol.add(list);
is illegal because we may have a List<List<String>> lol
and a List<Object> list
. In fact, if we comment out the offending statement, the code compiles and that’s exactly what we have with the first invocation in main
.
All of the probablyIllegal
methods in the question, aren’t illegal. They are all perfectly legal and typesafe. There is absolutely no bug in the compiler. It is doing exactly what it’s supposed to do.
References
Related questions
- Any simple way to explain why I cannot do
List<Animal> animals = new ArrayList<Dog>()
? - Java nested wildcard generic won’t compile
Appendix: The rules of capture conversion
(This was brought up in the first revision of the answer; it’s a worthy supplement to the type invariant argument.)
5.1.10 Capture Conversion
Let G name a generic type declaration with n formal type parameters A1…An with corresponding bounds U1…Un. There exists a capture conversion from G<T1…Tn> to G<S1…Sn>, where, for 1 <= i <= n:
- If Ti is a wildcard type argument of the form
?
then …- If Ti is a wildcard type argument of the form
? extends
Bi, then …- If Ti is a wildcard type argument of the form
? super
Bi, then …- Otherwise, Si = Ti.
Capture conversion is not applied recursively.
This section can be confusing, especially with regards to the non-recursive application of the capture conversion (hereby CC), but the key is that not all ?
can CC; it depends on where it appears. There is no recursive application in rule 4, but when rules 2 or 3 applies, then the respective Bi may itself be the result of a CC.
Let’s work through a few simple examples:
List<?>
can CCList<String>
- The
?
can CC by rule 1
- The
List<? extends Number>
can CCList<Integer>
- The
?
can CC by rule 2 - In applying rule 2, Bi is simply
Number
- The
List<? extends Number>
can NOT CCList<String>
- The
?
can CC by rule 2, but compile time error occurs due to incompatible types
- The
Now let’s try some nesting:
List<List<?>>
can NOT CCList<List<String>>
- Rule 4 applies, and CC is not recursive, so the
?
can NOT CC
- Rule 4 applies, and CC is not recursive, so the
List<? extends List<?>>
can CCList<List<String>>
- The first
?
can CC by rule 2 - In applying rule 2, Bi is now a
List<?>
, which can CCList<String>
- Both
?
can CC
- The first
List<? extends List<? extends Number>>
can CCList<List<Integer>>
- The first
?
can CC by rule 2 - In applying rule 2, Bi is now a
List<? extends Number>
, which can CCList<Integer>
- Both
?
can CC
- The first
List<? extends List<? extends Number>>
can NOT CCList<List<Integer>>
- The first
?
can CC by rule 2 - In applying rule 2, Bi is now a
List<? extends Number>
, which can CC, but gives a compile time error when applied toList<Integer>
- Both
?
can CC
- The first
To further illustrate why some ?
can CC and others can’t, consider the following rule: you can NOT directly instantiate a wildcard type. That is, the following gives a compile time error:
// WildSnippet1
new HashMap<?,?>(); // DOES NOT COMPILE!!!
new HashMap<List<?>, ?>(); // DOES NOT COMPILE!!!
new HashMap<?, Set<?>>(); // DOES NOT COMPILE!!!
However, the following compiles just fine:
// WildSnippet2
new HashMap<List<?>,Set<?>>(); // compiles fine!
new HashMap<Map<?,?>, Map<?,Map<?,?>>>(); // compiles fine!
The reason WildSnippet2
compiles is because, as explained above, none of the ?
can CC. In WildSnippet1
, either the K
or the V
(or both) of the HashMap<K,V>
can CC, which makes the direct instantiation through new
illegal.