Why this java snippet code compile just fine?

1.1 example

import java.util.*;

public class LOLUnknowns1 {
    static void probablyIllegal(List<List<?>> lol, List<?> list) {
        lol.add(list); // this compiles just fine
    }
}

How come this 1.1 code compile if we may end up having List<List<Integer>> lol and a List<String> list?

this following code snippet:
1.2 example

import java.util.*;

public class TwoListsOfUnknowns2 {
    static void doSomethingIllegal(List<?> list1, List<?> list2) {
        list1.addAll(list2); // DOES NOT COMPILE as expected!!!
            
    }
}

1.1 example baffles me, how is that possible to be compiled just fine?

I wnat to know the specific reason why a code compiled when it was expected not to from my understanding

> How come this 1.1 code compile if we may end up having List<List<Integer>> lol and a List<String> list?

You can not pass a List<List<Integer>> to an argument of type List<List<?>>. If you try:

probablyIllegal(new ArrayList<List<Integer>>(), new ArrayList<String>());

you get

> The method probablyIllegal(List<List<?>>, List<?>) in the type LOLUnknowns1 is not applicable for the arguments (ArrayList<List<Integer>>, ArrayList<String>).

The reason is that even though a List<Integer> is a subtype of List<?>, List<List<Integer>> is not a subtype of List<List<?>>, just like, even though String is a subtype of Object, List<String> is not a subtype of List<Object>.

If you want to be able to pass a List<List<Integer>>, you need to declare the argument to be of type List<? extends List<?>>:

static void probablyIllegal(List<? extends List<?>> lol, List<?> list) {
    lol.add(list); 
}

After that change, the compiler will accept your call, but reject your method implementation:

> 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#2-of ?>)

The error message is a bit cryptic (you need to read up on wildcard capture to understand it), but it basically says that you can't add the List<?> to a List<? extends List<?>> because you don't know what kind of elements lol contains, and therefore can not know that list is of a compatible type.

To conclude, you can either specify a specific element type for the List, in which case you can add, but not use a List of a different type, or you can leave the element type of the List unspecified, in which case you can use any List, but not add anything to it. Either way, nothing bad happens.

Re 1.1

As long as you don't use extends or super in a generic declaration with wildcards the compiler can't decide whether this will work or not at runtime since with the sole ? you tell it: I want to accept anything, and so does add(E e).

Have you tried running the code with concrete List objects passed as lol, list, list1, list2 arguments?

Re 1.2

The error (in Eclipse here) is:

> The method addAll(Collection&lt;? extends capture#1-of ?>) in the type List<capture#1-of ?> is not applicable for the arguments (List<capture#2-of ?>)

So, there are two different wildcard captures. One of Collection<?> (#1; expected by addAll(Collection<? extends E> c))/List<?> list1 and one of List<?> list2 (#2).

Now, see the article under the first link above:

> However, a collection of Object is not the supertype of any collection.
>
> For example, a List&lt;Object> is not the supertype of List&lt;String>, [...]

You declare list1 to be a List of anything (?₁) hence addAll() expects something (?₂) that extends anything (E = ?₁) but, see the citation, that's not how generics work.

I think this is what are you looking for.

To summarise a bit, for the second example you have can be done by a upper-bounded wildcard, if you want to have a list of more types.

In your first example you have an extra wrapper, the List<?> this is why it works, in the end a method from the List interface is used.