使用类型集合时编译错误对方法的模糊引用

Question

In the same class i have two overloading methods:

public static <T> void foo(Collection<T> collection, T valueToAppend);
public static <T> void foo(Collection<T> collection, Collection<T> valueToAppend);

The following test should call The second method:

 @Test 
   public void testFoo() {
   ArrayList ftList = Lists.newArrayList();
   List<Double> doubleList = Lists.newArrayList(1.0, 2.0);
   foo(ftList, doubleList);
}

When i run the test i get the following compilation error:

reference to foo is ambiguous, both method foo(java.util.Collection,T) in path.to.class and method foo(java.util.Collection,java.util.Collection) in path.to.class match.

I'm passing a collection in the second argument so why doesn't the compiler know to go to the second method?
If i change the methods signature and remove the generics from the first parameter i will not get compilation error, why is that?

Answer 1

Here is my explanation. When the compiler has to choose between overloadings, it always chooses the most specific overloading. When you strip the type information from the first parameter, the signatures become

public static <T> void foo(Collection collection, T valueToAppend)
public static <T> void foo(Collection collection, Collection<T> valueToAppend)

The second of these is more specific. Any pair of parameters that can be accepted by the second method can also be accepted by the first, because any Collection is an Object . Therefore when you strip the type parameter away, there is no ambiguity - the second method is chosen if you pass two Collection s.

However with the type information, the signatures look like this:

public static <T> void foo(Collection<T> collection, T valueToAppend)
public static <T> void foo(Collection<T> collection, Collection<T> valueToAppend)

Neither of these signatures is more specific than the other. The parameters new ArrayList<String>() and "Foo" will be accepted by the first signature but not the second. The parameters new ArrayList<String>() and new ArrayList<String>() will be accepted by the second signature but not the first.

So if both signatures apply, there is a problem.

You are trying to pass a raw ArrayList and a List<Double> . Because you are using a raw type ArrayList (which you should never do), ftList can pass as a Collection<T> for any T (Try it. Try passing a raw List to a method with parameter of type List<String> . It works). Therefore you only need to see that doubleList matches the second parameter for both overloadings. It matches the first signature if T is List<Double> and matches the second signature if T is Double .

Answer 2

因为第二个参数<T>也可以是一个Collection ，所以解释器会混淆它是Collection<T>还是<T>

Answer 3

编译器无法识别<T>和Collection<T>