Java Varargs

Varargs (variable-length arguments) let a method accept zero, one, or many arguments of the same type without the caller having to build an array explicitly. The syntax uses three dots after the type: Type... name, and inside the method body, that parameter behaves exactly like an array of that type.

Why it matters

Varargs lets a method accept any number of arguments without the caller building an array, which is how String.format and List.of work. It is convenient, but it has rules — one per method, last in the list — and it is the last choice in overload resolution, which can make a call pick a different method from the one you expected.

Varargs Syntax and Rules

A varargs parameter is declared as returnType methodName(Type... name). Two rules are strict and enforced by the compiler.

• A method can have at most one varargs parameter.
• The varargs parameter must be the last parameter in the method signature.
• Inside the method, the varargs parameter is treated as an ordinary array (Type[]), so you can use .length, indexing, and enhanced for-loops on it.
• Callers may pass individual comma-separated values, an existing array of that type, or nothing at all (an empty array is created automatically).

Overload Resolution with Varargs

When a call could match either a fixed-arity overload or a varargs overload, Java always prefers the fixed-arity (non-varargs) method if one matches exactly, and only falls back to the varargs version when no better match exists. This avoids unnecessary array creation whenever a simpler overload is available.

Example

public class VarargsDemo {
    static int sum(String label, int... numbers) {
        int total = 0;
        for (int n : numbers) {
            total += n;
        }
        System.out.println(label + ": " + numbers.length + " values, total " + total);
        return total;
    }

    public static void main(String[] args) {
        sum("Call 1");                  // zero arguments
        sum("Call 2", 5);               // one argument
        sum("Call 3", 1, 2, 3, 4);      // multiple arguments

        int[] existing = {10, 20, 30};
        sum("Call 4", existing);        // passing an existing array directly
    }
}

Call 1: 0 values, total 0
Call 2: 1 values, total 5
Call 3: 4 values, total 10
Call 4: 3 values, total 60

Exercise

Write average(int... values) so that it returns the average of its arguments as a double, and returns 0.0 when called with no arguments instead of dividing by zero.

Expected output: 4.0 then 0.0

public class Average {

    static double average(int... values) {
        // TODO: return 0.0 when there are no values
        // TODO: otherwise return the sum divided by the count, as a double
        return 0;
    }

    public static void main(String[] args) {
        System.out.println(average(2, 4, 6));
        System.out.println(average());
    }
}

public class Average {

    static double average(int... values) {
        if (values.length == 0) {
            return 0.0;
        }
        int sum = 0;
        for (int value : values) {
            sum += value;
        }
        return (double) sum / values.length;
    }

    public static void main(String[] args) {
        System.out.println(average(2, 4, 6)); // 4.0
        System.out.println(average());        // 0.0
    }
}

Quick quiz

Interview questions