Java Variable Length Parameter vs. Array, Simply Syntactic Sugar?

Question

I am taking a Data Structures and Algorithms course for fun at a local community college. The course's textbook is Y. Daniel Liang's Introduction to Java Programming, 10th Edition. The book, itself, is pretty solid.

In dealing with Java.util.Arrays, Liang mentions Java's "variable-length" parameter. He writes (p. 265):

Java treats a variable-length parameter as an array. You can pass an array or a variable number of arguments to a variable-length parameter. When invoking a method with a variable number of arguments, Java creates an array and passes the arguments to it.

An example being:

public static void (int... toes) {
    //... some code
}

However, Liang never explains the origin or advantage of the variable-length parameter. If, as Liang says, the variable-length parameter is "converted" to an array, what is their advantage? Is there a software design pattern or engineering goal that is facilitated by the variable length parameter?

In other words, what does the above code snippet offer that is not offered by the below:

public static void (int[] toes) { // ...

One benefit is that using '...' gives you the option to not pass in any parameters at all. — Zarwan
– Zarwan, Commented Aug 30, 2015 at 19:05
@Zar I did not know that. Is that somewhat akin then to optional parameters in VB, etc? — Thomas
– Thomas, Commented Aug 30, 2015 at 19:06
I haven't used VB, but in a sense it is "optional." Also, another thing is that it lets you pass in parameters without having to convert them into an array first. Also note that '...' parameters must be the last parameter in your method, while array parameters can be anywhere. — Zarwan
– Zarwan, Commented Aug 30, 2015 at 19:08
I wouldn't have thought it is like an optional parameter, as if you don't pass a value, the parameter is considered null. Having var-args, allows for some nice API design too, say you want a method to process ints, and it most have at least one int, you could create the method as method(int initial, Integer... others); When it is called it might be called method(1), method(1, 2) or method(1, 2, 3), they would all be valid — Gavin
– Gavin, Commented Aug 30, 2015 at 19:18

Community · Accepted Answer · 2017-05-23 10:26:34Z

10

The '...' parameters you are talking about are called varargs.

Some differences to note:

varargs can be passed no parameters (basically ignored), null, or an indeterminate number of arguments, while array parameters must be passed an array or null
varargs must be the last parameter of your method, whereas it doesn't matter for array parameters. This is because of this special property of varargs, which is probably the most significant difference between the two things you posted:

The three periods after the final parameter's type indicate that the final argument may be passed as an array or as a sequence of arguments

Source

So for example, this method:

public void myMethod(String... args) {}

Could be called with either of these:

String[] myStrings = {"a", "b", "c"};
myMethod(myStrings);
myMethod("a", "b", "c");

See this for a good explanation on when varargs should be used.

edited May 23, 2017 at 10:26

CommunityBot

11 silver badge

answered Aug 30, 2015 at 19:19

Zarwan

5,8674 gold badges32 silver badges48 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Nayuki · Accepted Answer · 2015-08-30 19:39:31Z

5

In Java, varargs are a syntactical sugar for creating an array when calling a method. For example, these two calls are equivalent:

void foo(String... args) { ... }

foo("hello", null, "world", xyz);  // Java 1.5+
foo(new String[]{"hello", null, "world", xyz});  // All versions of Java

Varargs doesn't make anything new possible (by definition of syntactic sugar), but it reduces verboseness and makes some constructs much more agreeable to implement. For example, some of my favorite uses of vararg include: PrintStream.printf(), String.format(), Method.invoke().

Other good applications of varargs:

// This one is in the Java standard library
Collections: void addAll(Collection<? super T> c, T... elements);

// Custom examples
int max(int... nums);
void doOperation(File x, String y, SomeEnum options...);

Additionally, Java's varargs bring the language up to parity with the vararg support in C, Python, JavaScript, and other languages. So if a frequently recurring design (such as max()) works best with varargs, Java is no longer the odd language that requires an uglier implementation.

edited Aug 30, 2015 at 19:39

answered Aug 30, 2015 at 19:32

Nayuki

18.8k6 gold badges61 silver badges84 bronze badges

1 Comment

Thomas Over a year ago

I deleted my previous comment (just so you are aware) and accepted your answer. While another answer with higher votes certainly provides great detail, your answer deals more specifically with the OP question: ...what is their advantage? Is there a software design pattern or engineering goal that is facilitated by the variable length parameter?

Collectives™ on Stack Overflow

Java Variable Length Parameter vs. Array, Simply Syntactic Sugar?

2 Answers 2

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related