Why can't I add an instance of A to a collection declared as Set?

Question

I have:

class Document { ... }

class DocumentCluster extends Document { ... }

And I'm trying to define a set of documents this way:

Set<? extends Document> docs = new HashSet<Document>();

However, when I'm trying to insert a document to my set:

docs.add(d);

I'm getting:

The method add(capture#10-of ? extends Document) in the type Set<capture#10-of ? extends Document> is not applicable for the arguments (Document)

What am I doing wrong?

@DanPantry That's not a very instructive way of putting it... Immutability is a runtime-enforced property, whereas generic types aren't. — Marko Topolnik, Jan 20 '14 at 11:46

Has QUIT--Anony-Mousse · Accepted Answer · 2014-01-20T12:02:46.070

Because it might only allow objects of type B.

A classic question, answered a million of times. Non-intuitive, but also not a design bug of Java.

Here is the classic example: let A be Fruit.

Can I put an Apple into a Set<? extends Fruit>?

No, because it could be a Set<Banana> which obviously must not contain apples.

? extends Fruit says some specific kind of fruit, and not "any kind of fruit". Then it would be a Set<Fruit> which indeed can take any kind of Fruit.

As a rule of thumb:

when putting ? super Fruit is convenient. It takes "at least" fruits
when getting ? extends Fruit is convenient. It may return only one kind of fruit, but they will all be fruit.

Consider this method:

public static double computeAverage(Collection<? extends Number> col) {
    double sum = 0.;
    for (Number n : col) {
      sum += n.doubleValue();
    }
    return sum / n.size();
}

This method can work with List<Integer>. Because it does not put Double into the list, but only takes Number objects out.

public static void put(Collection<? super Number> col, Number n) {
    col.put(n);
}

Here, we have the opposite case. We need a list that accepts arbitrary numbers (otherwise, we could not put the unspecific number in it). It may accept more, though:

put(new List<Object>(), (Double) 1.);

is valid, because I may put doubles into a list of Objects.

But the compiler correctly prevents put( new List<Integer>(), (Double) 1.).

It can get much messier than that:

public static <I,O> void transfer(Collection<? extends I> input,
                                  Collection<? super O> output,
                                  Converter<? super I, ? extends O> converter) {
  for (I inobj : input) {
    O outobj = converter.convert(inobj);
    output.put(outobj);
  }
}

But the compiler may be unable to figure out I and O automatically for you every time.

So what are the benefits of using Set extends Fruit> to Set ? — Shmoopy, Jan 20 '14 at 11:46
That you can get `Fruit` out of a `Set` without known what an `Apple` actually is. — Has QUIT--Anony-Mousse, Jan 20 '14 at 11:47
This might need to be a new question but I might as well try. I need to pass Set to a method accepting Set where B extends A. Is casting the only solution? — Shmoopy, Jan 20 '14 at 12:02
No, the solution is to find out whether A) the *other* should have used `Set extends A>`, or B) it actually won't work. Casting is just pretending it will work somehow, despite your code saying that it is *incorrect*. I.e. casting may hide an API specification error. — Has QUIT--Anony-Mousse, Jan 20 '14 at 12:04
Pretty much the *only* exception I know is due to a Java limitation involving `Class>` objects for *generic* types. Here, it may be necessary to cast e.g. `Class> klass = (Class>) Set.class;`. Note that this is a "cast to add Generic type arguments", it is not *changing* the arguments. — Has QUIT--Anony-Mousse, Jan 20 '14 at 12:08

score 0 · Answer 2 · answered Jan 20 '14 at 11:48

Set<? extends A> can't be added to because you don't exactly what type you are adding to the collection, only that you are adding SOMETHING that extends A. You can guarentee that when you use get() you will get a class that extends A, but when you use add() because you don't know the definitive type, you can't add to the collection

If you want to take advantage of polymorphism, use Set<A>. This will do the exact same thing - any member that is type compatible, ie, extends, from A can be placed in the Set<K>.

EDIT: @Anony-Mousse explained this much better with an example.

Why can't I add an instance of A to a collection declared as Set?

2 Answers2