Even if I’ve rarely seen var-args used in real projects, this feature seems useful although its behaviour is disturbing.
If you write this method :
void m (String... vargs) {}
You can use both var-args and arrays as shown below :
m("a", "b", "c"); m(new String[]{"a", "b", "c"});
Why can we swap these both calls without disturbing the JVM ?
Moreover, if you use var-args on the main method, it’ll compile and run fine :
public static void main (String... argv) {}
For me, it’s a proof that in the bytecode these two features are equals, and we’ll check this.
In fact, at compile time, javac replaces var-args by an array like this :
// In source : void m (String... args) {} // In bytecode void m (String[] args) {}
So var-args don’t really exist, it’s just syntaxical sugar for developers !
But … there still is a little problem. Why can’t we use var-args if the prototype uses array ?
For example this code doesn’t compile :
// Method definition m(String[] args) {} // Using our method m("a", "b", "c"); // Compilation fails
The explanation is : when you write a var-args based prototype, and you call your method using var-args (not array), at compile time javac replaces your var-args parameters by an array like in the following snippet.
// Method declaration m(String... args) {} // Using our method m("a", "b", "c");
The real call will be :
// Using our method m(new String[] {"a", "b", "c"});
Thus var-args really are syntaxical sugar, and this feature is a bit limited.
One more time, thanks to jad !