Why overloading a varargs method doesn't work for the primitive type and its object wrapper type?

Let's take a look at the following example:

Example I.
public class Program {
 
  public void operation(String str, Integer... data) { 
 String signature = "(String, Integer[])"; 
 out.println(str + "= > " + signature); } 
  
  public void operation(String str, int... data) { 
 String signature = "(String, int[])"; 
 out.println(str + "= > " + signature); } 

  public static void main(String[] args) {
 Program ref = new Program();
 ref.operation("(String, int)", 1); //compile error

  }
}

Example I does not compile. The error is "The method operation(String, Integer[]) is ambiguous for the type Program".

At compile time a vararg is converted to an array. In example I, 1 will be converted to an int array with 1 as the only element, something like int[] a={1}; with the autoboxing, 1 can also be converted to an Integer array, something like Integer [] b={1}; so if the Program class had only one operation() method, either method would work fine.

On the other hand, for method overloading to work, the compiler needs to figure out which method is the most-specific method. We already know that if the args are fixed, like in Example II:

Example II.
public class Program {

  public void operation(int data) {
 System.out.println("(int)");
  }

  public void operation(Integer data) {
    System.out.println("(Integer)");
  }

  public static void main(String [] args) {
    Program ref = new Program();
 ref.operation(1); 
  }
}

output: 
int

the operation(int data) is the most-specific method for ref.operation(1). Because the primitive type is most specific, not the wrapper class type.

But in Example I, an int[] and an Integer[] can't compared, they are both Array objects, neither one is more specific then the other one. So in this case, the compiler can't decide which method is the most-specific to call for ref.operation("(String, int)", 1);

This is true for other primitive types, if we change the int to boolean in Example I, it produces a similar compile time error: "The method operation(Boolean[]) is ambiguous for the type Program".

Example III.
public class Program {
 public void operation(Boolean... data) { 
 String signature = "(Boolean[])"; 
 out.println(str + "= > " + signature); } 
  
  public void operation(boolean... data) { 
 String signature = "(boolean[])"; 
 out.println(str + "= > " + signature); } 

  public static void main(String[] args) {
 Program ref = new Program();
 ref.operation(false, true); //compile error
  }
}

Click below links to know more