Java incompatible type cannot be converted to wildcard parameter inside HashMap<>

Question

Recently I have come across the following error during compilation:

error: incompatible types: HashMap<Integer, HashMap<Object, Consumer<A>>> cannot be converted
to HashMap<Integer, HashMap<Object, Consumer<? extends B>>>

In this code, class A is a direct subclass of B.

This error occurred in the following snippet:

HashMap<Integer, HashMap<Object, Consumer<A>>> item = new HashMap<>();
HashSet<HashMap<Integer, HashMap<Object, Consumer<? extends B>>>> set = new HashSet();
set.add(item);

In attempting to resolve the error I have already tried removing the ? extends bit from the HashMap inside of the HashSet, but the compiler kept throwing the error.

`A is a direct subclass of B.` This looks like a direct application of "generics aren't covariant." https://stackoverflow.com/questions/8481301/covariance-invariance-and-contravariance-explained-in-plain-english — markspace, Apr 05 '22 at 23:26

Oussama ZAGHDOUD · Answer 1 · 2022-04-06T01:11:42.897

0

Consumer<A> and Consumer<? extends B> are totally different , in fact Consumer<? extends B> can be Consumer<C> where C is another class who extends B.

The same with Consumer<A> and Consumer<B> they are not the same thing, an instance of B class is not an instance of A class, so deleting the ? extends still give you a compile time error.

import java.util.ArrayList;
import java.util.List;

public class Test {
    static class Lion extends Animal {
    }
    static class Animal {
    }
    public static void main(String[] args) {
        List<? extends Animal> animals = new ArrayList<Animal>();
        animals .add(new Lion()); // DOES NOT COMPILE 

        // at compile time , our List(reference) may be a List of Animal or List of Lion , not a List of both of them
        
        // using ? extends Animal to refer the ArrayList instance 
        // we cannot add a Lion to an ArrayList of Animal

        animals .add(new Animal()); // DOES NOT COMPILE

        // the same using the ? extends Animal as reference 
       // we cannot add an animal to an ArrayList of Lion
    }
}

edited Apr 06 '22 at 01:11

answered Apr 05 '22 at 23:33

Oussama ZAGHDOUD

1,767
5
15

No, this is incorrect. `A` is a subclass of `B`, so `Consumer` is a subtype of `Consumer extends B>`. – Dawood ibn Kareem Apr 05 '22 at 23:34
3

I'm pretty sure you are wrong, Dawood, and in Java generics `Consumer` and `Consumer extends B>` are in fact totally different types. Can you cite sources for your assertion? – markspace Apr 05 '22 at 23:37
You're welcome to be "pretty sure" about whatever you like, @markspace, but what I said is _literally_ what `extends` inside the `< >` means. You can test this out for yourself by writing a little program where `A extends B` and where you use a variable of type `Consumer extends B>` to refer to an object of type `Consumer`. I have done this myself literally hundreds of times. This answer is incorrect, despite someone upvoting it. – Dawood ibn Kareem Apr 05 '22 at 23:41
@DawoodibnKareem can you please take a look at the updated answer, i tried to add an example , you can copy past it in your IDE. – Oussama ZAGHDOUD Apr 05 '22 at 23:51
Sure. The reason why `animals.add(new Lion())` doesn't compile in your new example is because although `List` is a subtype of `List extends Animal>`, it's not the other way around. So you can't add a `Lion` to `animals`, because based on the type of `animals`, it could reference a `List`. You are trying to do something to a variable of type `List extends Animal>` that can only be done to specific subtypes of `List extends Animal>`. – Dawood ibn Kareem Apr 05 '22 at 23:55
@DawoodibnKareem , it is the same problem of the question , reference using Consumer extends B> make the compiler prevent any add of type Consumer – Oussama ZAGHDOUD Apr 06 '22 at 00:09
No, the problem in the question is much more complex, because the Consumer is inside a HashMap of HashMaps. If you were to remove the HashMaps from the question, you wouldn't get that error. You'd never see `Consumer cannot be converted to Consumer extends B>`, because a `Consumer ` is in fact a `Consumer extends B>`. – Dawood ibn Kareem Apr 06 '22 at 00:12
On the other hand, you _could_ get `HashMap – Dawood ibn Kareem Apr 06 '22 at 00:17
@DawoodibnKareem Obviously you’re correct that `Consumer` is matched by `Consumer extends B>`, but I disagree with your use of “subtype.” I think the use of that word is causing some confusion here. The fact that A is a subtype of B does not imply that `Consumer ` is a subtype of `Consumer extends B>`. A more illustrative example is that one cannot do the same operations with `List extends B>` that one can do with `List `. – VGR Apr 06 '22 at 13:50
@VGR You are mistaken. The fact that one cannot do the same operations with `List extends B>` that one can do with `List` means that `List extends B>` is not a subtype of `List `. It's a supertype. The fact that every `List ` is also a `List extends B>` is the very definition of a subtype. You're getting subtype and supertype reversed. – Dawood ibn Kareem Apr 06 '22 at 19:02

Java incompatible type cannot be converted to wildcard parameter inside HashMap<>

1 Answers1