VarArgs vs Array Input Parameters in Java

1. Overview

In this tutorial, we’ll explore the difference between method(String… args) and method(String[] args) in Java. Along the way, we’ll examine how to pass an array or a variable-length argument list to a method.

2. Passing Arrays to Methods

In this section, we’ll show how to declare an array of type String as a method’s parameter and how to pass an array of the same type as an argument during a method invocation.

Java is a statically-typed programming language, meaning that the variable type is known at compile time. A programmer must state a variable type, either primitive or reference. When defining a method with an array parameter, it’s expected that we declare the type of array we want to be passed as an argument during the method call.

Let’s see the syntax for defining a String array parameter in a method header:

void capitalizeNames(String[] args)

Let’s break down the argument declared in the method header above:

• String[] – type name
• args – parameter name

void capitalizeNames(String[] args) {
    for(int i = 0; i < args.length; i++){
       args[i] = args[i].toUpperCase();
    }
}

From the above, the capitalizeNames() method has a String array parameter args. The method header specifies that the method receives only one array reference of java.lang.String[] type when called.

In essence, when we encounter (String[] args) in a method header, we should understand that the method takes a single array of type String as an argument when called.

Let’s look at an example:

@Test
void whenCheckingArgumentClassName_thenNameShouldBeStringArray() {
    String[] names = {"john", "ade", "kofi", "imo"};
    assertNotNull(names);
    assertEquals("java.lang.String[]", names.getClass().getTypeName());
    capitalizeNames(names);
}

When we check the class name of the capitalizeNames() method argument, names, we get java.lang.String[], which matches the parameter in the method definition. If we try to pass a different type as an argument to the method, we’ll get a compilation error:

@Test
void whenCheckingArgumentClassName_thenNameShouldBeStringArray() {
    ...
    int[] evenNumbers = {2, 4, 6, 8};
    capitalizeNames(evenNumbers);
}

The above code snippet would output the compiler error message on our console:

incompatible types: int[] cannot be converted to java.lang.String[]

3. Variable-Length Argument Lists

Variable-length argument lists, also known as varargs in Java, allow us to pass an arbitrary number of arguments of the same type during a method call.

The syntax for variable-length argument lists in a method looks like:

String[] firstLetterOfWords(String... args)

Let’s break down the argument declared in the method header above:

• String… – type name with ellipsis
• args – parameter name

String[] firstLetterOfWords(String... args) {
    String[] firstLetter = new String[args.length];
    for(int i = 0; i < args.length; i++){
        firstLetter[i] = String.valueOf(args[i].charAt(0));
    }
    return firstLetter;
}

We declare the parameter type followed by an ellipsis (…) and the parameter name in our method signature.

With variable-length argument lists, we can add any number of arguments of the same type to a method because Java handles the given arguments as elements in an array. When adding varargs as part of a method parameters, ensure the type, ellipsis, and parameter name come last.

For example, this would be incorrect:

static String[] someMethod(String... args, int number)

We can easily fix this by swapping the order of the arguments, putting the varargs parameter last:

static String[] someMethod(int number, String... args)

Let’s test the firstLetterOfWords method we wrote above:

@Test
void whenCheckingReturnedObjectClass_thenClassShouldBeStringArray() {
    assertEquals(String[].class, firstLetterOfWords("football", "basketball", "volleyball").getClass());
    assertEquals(3, firstLetterOfWords("football", "basketball", "volleyball").length);
}

We know that the firstLetterOfWords() method takes variable-length argument lists of type String because of the ellipsis, and we pass the same as arguments. The test shows that the method returns an array when we access its getClass() attribute. We also get 3 when we access the array’s length property, which matches the number of arguments passed to it.

4. (String[] args) vs. (String… args)

String[] args indicate an array of type String as a method parameter in Java. It’s often found as an array parameter of the main method in Java classes. The String[] args parameter in the main method forms a String array from command line arguments. When invoking a method with (String[] args), a String array must be passed in as an argument.

We can only have one variable-length argument list when defining a method. Varargs is not just limited to the java.lang.String type. We can have other types like (int… args), (double… args), and so on. Under the hood, Java takes all arguments passed when invoking a method with varargs and makes an array out of it. However, we can invoke a method with varargs parameters without an argument, in which case it will be treated as an empty array.

Remember that args as a variable name is just a convention — any other appropriate name can be used instead.

5. Conclusion

In this tutorial, we examined the difference between method(String[] args) and method(String… args). The first is a method with a String array parameter, while the latter is a method with a variable-length argument list (varargs).

Varargs are always placed as the last parameter in a method’s parameters list, thus a method can declare only one varargs argument.