difference fn(String... args) vs fn(String[] args)

Solution 1:

The only difference between the two is the way you call the function. With String var args you can omit the array creation.

public static void main(String[] args) {
    callMe1(new String[] {"a", "b", "c"});
    callMe2("a", "b", "c");
    // You can also do this
    // callMe2(new String[] {"a", "b", "c"});
}
public static void callMe1(String[] args) {
    System.out.println(args.getClass() == String[].class);
    for (String s : args) {
        System.out.println(s);
    }
}
public static void callMe2(String... args) {
    System.out.println(args.getClass() == String[].class);
    for (String s : args) {
        System.out.println(s);
    }
}

Solution 2:

The difference is only when invoking the method. The second form must be invoked with an array, the first form can be invoked with an array (just like the second one, yes, this is valid according to Java standard) or with a list of strings (multiple strings separated by comma) or with no arguments at all (the second one always must have one, at least null must be passed).

It is syntactically sugar. Actually the compiler turns

function(s1, s2, s3);

into

function(new String[] { s1, s2, s3 });

internally.

Solution 3:

with varargs (String...) you can call the method this way:

function(arg1);
function(arg1, arg2);
function(arg1, arg2, arg3);

You can't do that with array (String[])

Solution 4:

You call the first function as:

function(arg1, arg2, arg3);

while the second one:

String [] args = new String[3];
args[0] = "";
args[1] = "";
args[2] = "";
function(args);

Solution 5:

On the receiver size you will get an array of String. The difference is only on the calling side.