Varargs (Variable Arguments) in Java

Last Updated: 27 October, 2023

Varargs, which means variable argument, is a feature that was introduced in the Java 5 version that allows methods to accept a variable number of arguments.

To define a varargs method, simply add the ellipsis (...) operator to the end of the parameter type for the varargs parameter.

Varargs allows a method to accept none or multiple arguments.

Syntax of Varargs:

accessModifier methodName(datatype… arg) { // method body }

What approaches were we following before Varargs?

Before varargs, we were using two different approaches to achieve this functionality:

1. Using the overloaded method.
2. Passing an array as the method argument.

How does varargs work internally?

When we define a method with varargs (...), the Java compiler creates an array with generic type components to hold the arguments.

Rules for varargs:

1. Only one variable argument (varargs) is allowed in one method.

void testMethod(String str, int... args) { } // VALID CODE void testMethod(String str, int... args1, int... args2) { } // INVALID CODE



2. The varargs argument must be the last argument in a method.

void testMethod(String str, int... args) { } // VALID CODE void testMethod(int... args, String str) { } // INVALID CODE



3. Only put … (3 dots). If the dots are less or more than 3, then it gives a syntax error.

void testMethod(int... args) { } // VALID CODE void testMethod(int.. args) { } // INVALID CODE

Here are some examples of using varargs in Java:

Example 1: A Java program to demonstrate varargs

public class VarArgsExample1 { static void addNumbers(int... number) { int result = 0; for (int num: number) { result = result + num; } System.out.println("Total Added Values: " + result); } public static void main(String[] args) { // Not passing any argument addNumbers(); // Passing 1 argument addNumbers(10); // Passing 2 arguments addNumbers(10, 20); // Passing 3 arguments addNumbers(10, 20, 30); // Passing 4 arguments addNumbers(10, 20, 30, 40); } }

Output

Total Added Values: 0
Total Added Values: 10
Total Added Values: 30
Total Added Values: 60
Total Added Values: 100

Example 2: Ambiguity in Varargs Method Overloading

Vararg methods can also be overloaded in Java, but overloading may lead to ambiguity. Let's understand it using the below example.

public class VarArgsExample2 { static void addNumbers(int... number) { int result = 0; for (int num: number) { result = result + num; } System.out.println("Total Added Values: " + result); } static void addNumbers(int extraNumber, int... number) { int result = 0; for (int num: number) { result = result + num; } System.out.println("Total Added Values: " + result); } public static void main(String[] args) { addNumbers(10, 20); // Passing 2 arguments addNumbers(10, 20, 30); // Passing 3 arguments } }

Output

Exception in thread "main" java.lang.Error: Unresolved compilation problems: The method addNumbers(int[]) is ambiguous for the type VarArgsExample2 The method addNumbers(int[]) is ambiguous for the type VarArgsExample2 at com.varargs.example.VarArgsExample2.main(VarArgsExample2.java:23)

In this example, the compiler gets confused if we call the addNumbers(10, 20) method because addNumbers() is an overloaded method. The compiler doesn’t know which method to call. The compiler may think we are calling addNumbers(int... number) with one varargs argument. In the same way, the compiler may think we are calling addNumbers(int n, int... number) with the argument passed to the first argument with an empty second argument.

Since there are two possibilities, it causes ambiguity. To avoid ambiguity in the program, we need to use two different method names instead of overloading the varargs method.

Varargs can facilitate the creation of flexible and reusable code. Nevertheless, it is essential to use varargs with caution to avoid common pitfalls such as:

• Not checking the length of the varargs array before accessing its elements.
• Storing a reference to the varargs array outside of the method.
• Passing a null value to the varargs parameter.