StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

POMultiple wildcards on a generic methods makes Java compiler (and me!) very confused
primarykey
Id
3546745
data
AcceptedAnswerId
3547372
AnswerCount
3
ClosedDate
CommentCount
3
CommunityOwnedDate
CreationDate
2010-08-23T10:37:46.203
FavoriteCount
41
LastActivityDate
2012-06-15T10:23:40.397
LastEditDate
2010-08-23T11:39:56.650
LastEditorUserId
276101
OwnerUserId
276101
ParentId
0
PostTypeId
1
Score
55
ViewCount
6528
LastEditorDisplayName
text
Body
Let's first consider a simple scenario (<a href="http://ideone.com/jXOh0" rel="noreferrer">see complete source on ideone.com</a>): <pre><code>import java.util.*; public class TwoListsOfUnknowns { static void doNothing(List<?> list1, List<?> list2) { } public static void main(String[] args) { List<String> list1 = null; List<Integer> list2 = null; doNothing(list1, list2); // compiles fine! } } </code></pre> The two wildcards are unrelated, which is why you can call <code>doNothing</code> with a <code>List<String></code> and a <code>List<Integer></code>. In other words, the two <code>?</code> can refer to entirely different types. Hence the following does not compile, which is to be expected (<a href="http://ideone.com/moqSj" rel="noreferrer">also on ideone.com</a>): <pre><code>import java.util.*; public class TwoListsOfUnknowns2 { static void doSomethingIllegal(List<?> list1, List<?> list2) { list1.addAll(list2); // DOES NOT COMPILE!!! // The method addAll(Collection<? extends capture#1-of ?>) // in the type List<capture#1-of ?> is not applicable for // the arguments (List<capture#2-of ?>) } } </code></pre> So far so good, but here's where things start to get very confusing (<a href="http://ideone.com/YIy6Q" rel="noreferrer">as seen on ideone.com</a>): <pre><code>import java.util.*; public class LOLUnknowns1 { static void probablyIllegal(List<List<?>> lol, List<?> list) { lol.add(list); // this compiles!! how come??? } } </code></pre> The above code compiles for me in Eclipse and on <code>sun-jdk-1.6.0.17</code> in ideone.com, but should it? Is it not possible that we have a <code>List<List<Integer>> lol</code> and a <code>List<String> list</code>, the analogous two unrelated wildcards situations from <code>TwoListsOfUnknowns</code>? In fact the following slight modification towards that direction does not compile, which is to be expected (<a href="http://ideone.com/aS8WP" rel="noreferrer">as seen on ideone.com</a>): <pre><code>import java.util.*; public class LOLUnknowns2 { static void rightfullyIllegal( List<List<? extends Number>> lol, List<?> list) { lol.add(list); // DOES NOT COMPILE! As expected!!! // The method add(List<? extends Number>) in the type // List<List<? extends Number>> is not applicable for // the arguments (List<capture#1-of ?>) } } </code></pre> So it looks like the compiler is doing its job, but then we get this (<a href="http://ideone.com/A8dPb" rel="noreferrer">as seen on ideone.com</a>): <pre><code>import java.util.*; public class LOLUnknowns3 { static void probablyIllegalAgain( List<List<? extends Number>> lol, List<? extends Number> list) { lol.add(list); // compiles fine!!! how come??? } } </code></pre> Again, we may have e.g. a <code>List<List<Integer>> lol</code> and a <code>List<Float> list</code>, so this shouldn't compile, right? In fact, let's go back to the simpler <code>LOLUnknowns1</code> (two unbounded wildcards) and try to see if we can in fact invoke <code>probablyIllegal</code> in any way. Let's try the "easy" case first and choose the same type for the two wildcards (<a href="http://ideone.com/PzN9N" rel="noreferrer">as seen on ideone.com</a>): <pre><code>import java.util.*; public class LOLUnknowns1a { static void probablyIllegal(List<List<?>> lol, List<?> list) { lol.add(list); // this compiles!! how come??? } public static void main(String[] args) { List<List<String>> lol = null; List<String> list = null; probablyIllegal(lol, list); // DOES NOT COMPILE!! // The method probablyIllegal(List<List<?>>, List<?>) // in the type LOLUnknowns1a is not applicable for the // arguments (List<List<String>>, List<String>) } } </code></pre> This makes no sense! Here we aren't even trying to use two different types, and it doesn't compile! Making it a <code>List<List<Integer>> lol</code> and <code>List<String> list</code> also gives a similar compilation error! In fact, from my experimentation, the only way that the code compiles is if the first argument is an explicit <code>null</code> type (<a href="http://ideone.com/OYVEY" rel="noreferrer">as seen on ideone.com</a>): <pre><code>import java.util.*; public class LOLUnknowns1b { static void probablyIllegal(List<List<?>> lol, List<?> list) { lol.add(list); // this compiles!! how come??? } public static void main(String[] args) { List<String> list = null; probablyIllegal(null, list); // compiles fine! // throws NullPointerException at run-time } } </code></pre> So the questions are, with regards to <code>LOLUnknowns1</code>, <code>LOLUnknowns1a</code> and <code>LOLUnknowns1b</code>: <ul> <li>What types of arguments does <code>probablyIllegal</code> accept?</li> <li>Should <code>lol.add(list);</code> compile at all? Is it typesafe?</li> <li>Is this a compiler bug or am I misunderstanding the capture conversion rules for wildcards?</li> </ul> <hr> <h3>Appendix A: Double LOL?</h3> In case anyone is curious, this compiles fine (<a href="http://ideone.com/U65yx" rel="noreferrer">as seen on ideone.com</a>): <pre><code>import java.util.*; public class DoubleLOL { static void omg2xLOL(List<List<?>> lol1, List<List<?>> lol2) { // compiles just fine!!! lol1.addAll(lol2); lol2.addAll(lol1); } } </code></pre> <hr> <h3>Appendix B: Nested wildcards -- what do they really mean???</h3> Further investigation indicates that perhaps multiple wildcards has nothing to do with the problem, but rather a nested wildcard is the source of the confusion. <pre><code>import java.util.*; public class IntoTheWild { public static void main(String[] args) { List<?> list = new ArrayList<String>(); // compiles fine! List<List<?>> lol = new ArrayList<List<String>>(); // DOES NOT COMPILE!!! // Type mismatch: cannot convert from // ArrayList<List<String>> to List<List<?>> } } </code></pre> So it looks perhaps a <code>List<List<String>></code> is not a <code>List<List<?>></code>. In fact, while any <code>List<E></code> is a <code>List<?></code>, it doesn't look like any <code>List<List<E>></code> is a <code>List<List<?>></code> (<a href="http://ideone.com/XLoGE" rel="noreferrer">as seen on ideone.com</a>): <pre><code>import java.util.*; public class IntoTheWild2 { static <E> List<?> makeItWild(List<E> list) { return list; // compiles fine! } static <E> List<List<?>> makeItWildLOL(List<List<E>> lol) { return lol; // DOES NOT COMPILE!!! // Type mismatch: cannot convert from // List<List<E>> to List<List<?>> } } </code></pre> A new question arises, then: just what is a <code>List<List<?>></code>?
Tags
<java><generics><wildcard><compiler-errors>
Title
Multiple wildcards on a generic methods makes Java compiler (and me!) very confused
singulars
PostAcceptedAnswerId
1. PO
 singulars
 PostTypePostTypeId
 PTAnswer
PostParentId
1. This table or related slice is empty.
PostTypePostTypeId
1. PTQuestion
UserLastEditorUserId
1. USpolygenelubricants
UserOwnerUserId
1. USpolygenelubricants
plurals
PostLinksPostIdRelatedPostId
1. PL
 singulars
 LinkTypeLinkTypeId
 LTLinked
2. PL
 singulars
 LinkTypeLinkTypeId
 LTLinked
3. PL
 singulars
 LinkTypeLinkTypeId
 LTLinked
PostLinksRelatedPostIdPostId
1. PL
 singulars
 LinkTypeLinkTypeId
 LTLinked
2. PL
 singulars
 LinkTypeLinkTypeId
 LTLinked
3. PL
 singulars
 LinkTypeLinkTypeId
 LTLinked
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. PO
 singulars
 PostTypePostTypeId
 PTAnswer
2. PO
 singulars
 PostTypePostTypeId
 PTAnswer
3. PO
 singulars
 PostTypePostTypeId
 PTAnswer
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 POMultiple wildcards on a generic methods makes Java compiler (and me!) very confused
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 POMultiple wildcards on a generic methods makes Java compiler (and me!) very confused
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 POMultiple wildcards on a generic methods makes Java compiler (and me!) very confused
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.