Reputation: 2391

Are String [] and String... (Var-args) same when they work internally?

class WrongOverloading{
    void something(String [] a){ .. }
    Integer something(String... aaa){ return 1;}
}

Above code does not compile! Compiler says these are duplicate methods. So using String array or String var-args exactly mean the same?

How are they implemented internally?

Upvotes: 7

Answers (9)

krishna

Reputation: 1

while calling a method it doesnt care about the return type it will consider the method name , number of parameters and type of parameters and order of parameters .here you are specifying a method with same name same parameters .bcoz in case of var arg if we call method with 2 parameters same method will be executed , if we call method with 3 parameters it will call same method . here , if we call something(String [] a) and something(String... aaa) same method will be called .bcoz we can replace array with var-arg then a confusion will be arise wich method should be called. then method ambiguity will occour . thats why its showing duplicate method.

here if we pass array to var - arg parameter method it will be executed.internally it converts var - args to single dimensional array.

Upvotes: 0

Lion

Reputation: 19027

The [vararg] attribute specifies that the method takes a variable number of parameters. To accomplish this, the last parameter must be a safe array of VARIANT type that contains all the remaining parameters :

[vararg [, optional-attributes]] return-type function-name(
[optional-param-attributes] param-list,
SAFEARRAY(VARIANT) last-param-name);

The varargs syntax basically lets you specify that there are possible parameters, right? They can be there, or cannot be there. That's the purpose of the three dots. When you call the method, you can call it with or without those parameters. This was done to avoid having to pass arrays to the methods.

Have a look at this:

See When do you use varargs in Java?

final public class Main
{
    private void show(int []a)
    {
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+"\t");
        }
    }

    private void show(Object...a)
    {
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+"\t");
        }

        System.out.println("\nvarargs called");
    }

    public static void main(String... args)
    {
        int[]temp=new int[]{1,2,3,4};            

        Main main=new Main();
        main.show(temp);
        main.show();         //<-- This is possible.
    }
}

It's for this reason, varargs is basically not recommended in overloading of methods.

System.out.printf(); is an example of varargs and defined as follows.

public PrintStream printf(String format, Object ... args)
{
     return format(format, args);
}

format - A format string as described in Format string syntax

args - Arguments referenced by the format specifiers in the format string. If there are more arguments than format specifiers, the extra arguments are ignored. The number of arguments is variable and may be zero. The maximum number of arguments is limited by the maximum dimension of a Java array as defined by the Java Virtual Machine Specification. The behaviour on a null argument depends on the conversion.

Upvotes: 1

Kumar KL

Reputation: 15335

Yes, both are the same ... http://docs.oracle.com/javase/1.5.0/docs/guide/language/varargs.html Just read this site, you will come to know

Upvotes: 1

Peter Lawrey

Reputation: 533492

They are effectively the same, except the compiler will not accept an varargs unless its the last argument and it won't allow you to pass multiple arguments to an array.

public void methodA(int... ints, int a); // doesn't compile
public void methodA(int[] ints, int a); // compiles

public void methodB(int... ints); // compiles
public void methodC(int[] ints); // compiles

methodB(1); // compiles
methodB(1,2,3,4); // compiles
methodC(1); // doesn't compile
methodC(1,2,3,4); // doesn't compile

Upvotes: 6

Abimaran Kugathasan

Reputation: 32468

The compiler behind the scenes actually converts your var args method to a method with an array input. This is the reason why you can have a var args method overloaded with an array as input because after compilation both of them will be identical.

Upvotes: 1

blahman

Reputation: 1314

From this SO discussion

The underlying type of a variadic method function(Object... args) is function(Object[] args). Sun added varargs in this manner to preserve backwards compatibility.

So, as every other answer has said, yes, they're the same.

Upvotes: 4