Lists with wildcards cause Generic voodoo error

Question

Does anyone know why the following code does not compile? Neither add() nor addAll() works as expected. Removing the "? extends" part makes everything work, but then I would not be able to add subclasses of Foo.

 List<? extends Foo> list1 = new ArrayList<Foo>();
 List<? extends Foo> list2 = new ArrayList<Foo>();

 /* Won't compile */
 list2.add( new Foo() ); //error 1
 list1.addAll(list2);    //error 2

error 1:

IntelliJ says:

add(capture<? extends Foo>) in List cannot be applied to add(Foo)

The compiler says:

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>

error 2:

IntelliJ gives me

addAll(java.util.Collection<? extends capture<? extends Foo>>) in List cannot be applied to addAll(java.util.List<capture<? extends Foo>>)

Whereas the compiler just says

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>
        list1.addAll(list2);

Please explain why you use extends Foo>, instead just Foo. In explaining that, maybe things will get clear. — Ingo, Mar 23 '11 at 15:58
Hey, Ingo. Excellent point, and one that might have created better/more accurate answers earlier on. I was confused by method parameters using wildcards to accept subtypes, and thought I needed to use the extends Foo> notation to be able to add subtypes to the collection. Myers and Paulo (below) helped to get why that is not necessary (or right). Good comment - thanks! — oligofren, Mar 24 '11 at 08:56

score 64 · Accepted Answer · edited Mar 19 '18 at 18:49

(I assume here that Bar and Baz are both subtypes of Foo.)

List<? extends Foo> means a list of elements of some type, which is a subtype of Foo, but we don't know which type. Examples of such lists would be a ArrayList<Foo>, a LinkedList<Bar> and a ArrayList<Baz>.

As we don't know which subtype is the type parameter, we can't put Foo objects into it, neither Bar or Baz objects. But we still know that the type parameter is a subtype of Foo, so every element already in the list (and which we can get from the list) must be a Foo object, so we can use Foo f = list.get(0); and similar things.

Such a list can only be used for taking elements out of the list, not to adding elements at all (apart from null, but I don't know if the compiler actually allows this).

A List<Foo> on the other hand allows adding any object which is a Foo object - and as Bar and Baz are subtypes of Foo, all Bar and Baz objects are Foo objects, so they can be added, too.

Thanks, Paulo! The linked answer from Michael Myers was also very to the point, but your answer did not require a detour :) — oligofren, Mar 24 '11 at 08:51

score 29 · Answer 2 · edited May 23 '17 at 12:26

29

Remember PECS: Producer Extends, Consumer Super.

Since you are trying to add items to list2, it is a consumer and cannot be declared as List<? extends Foo>. But then you are using list2 as a producer also when you add it to list1. Therefore, list2 is both a producer and a consumer and must be a List<Foo>.

list1, as a pure consumer, can be a List<? super Foo>.

edited May 23 '17 at 12:26

Community

1
1

answered Mar 23 '11 at 15:56

Michael Myers

188,989
46
291
292

Thanks for your help - the PECS answer on the linked page is excellent! Upvoting for your linked answer, but awarding Paulo the credit for the accepted answer, since it didn't requre a detour to be comprehensive :) – oligofren Mar 24 '11 at 08:54

score 9 · Answer 3 · edited Mar 19 '18 at 19:25

They're errors. Lets modify your code, considering that Bar and Baz are two different types extending Foo:

List<? extends Foo> list1 = new ArrayList<Bar>();
List<? extends Foo> list2 = new ArrayList<Baz>();

If list1.add(new Foo()) was allowed, you could add Foo instances in a collection containing Bar instances. This explains the first error.

If list1.addAll(list2) was allowed, all instances of Baz in list2 would be added to list1, which contains only Bar instances. This explains the second error.

score 4 · Answer 4 · answered Feb 02 '17 at 12:35

Let me try to explain in what case you might need to use <? extend Classname>.

So, lets say you have 2 classes:

class Grand {
    private String name;

    public Grand(String name) {
        this.setName(name);
    }

    public Grand() {
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Dad extends Grand {
    public Dad(String name) {
        this.setName(name);
    }

    public Dad() {
    }
}

And lets say you have 2 collections, each contains some Grands and some Dads:

    List<Dad> dads = new ArrayList<>();
    dads.add(new Dad("Dad 1"));
    dads.add(new Dad("Dad 2"));
    dads.add(new Dad("Dad 3"));


    List<Dad> grands = new ArrayList<>();
    dads.add(new Dad("Grandpa 1"));
    dads.add(new Dad("Grandpa 2"));
    dads.add(new Dad("Grandpa 3"));

Now, lets asume that we want to have collection, which will contain Grand or Dad objects:

        List<Grand> resultList;
        resultList = dads; // Error - Incompatable types List<Grand> List<Dad>
        resultList = grands;//Works fine

How we can avoid this? Simply use wildcard:

List<? extends Grand> resultList;
resultList = dads; // Works fine
resultList = grands;//Works fine

Notice, that you cant add new items in such (resultList) collection. For more information you can read about Wildcard and PECS conseption in Java

I don't' see any difference between `List dads` and `List grands`, doesn't it? — Dred, Jul 08 '19 at 07:45

score 2 · Answer 5 · answered Mar 23 '11 at 15:58

2

Sorry, maybe I misunderstood your question, but suposing:

public class Bar extends Foo{ }

this code:

List<Foo> list2 = new ArrayList<Foo>()
list2.add( new Bar() );

do not generate any error for me.

So, removing the wild card allows adding subclasses of Foo.

answered Mar 23 '11 at 15:58

Tomas Narros

13,390
2
40
56

In the question, `List extends Foo>` is used as the variable type, not `List` :-) – Vivien Barousse Mar 23 '11 at 15:59
@Vivien: I know. What I state is that the wildcard can be removed for the code to compile. – Tomas Narros Mar 23 '11 at 16:01
And it will allow adding subclasses of Foo. – Tomas Narros Mar 23 '11 at 16:08

Lists with wildcards cause Generic voodoo error

5 Answers5

Linked

Related