Java Varargs: Methods That Take Any Number of Arguments

One Method, Any Number of Arguments

Sometimes you do not know up front how many arguments a method needs. You might want max(3, 9) one moment and max(1, 7, 4, 2, 8) the next. Without varargs you would write an overload for each count or force the caller to build an array. Varargs - short for variable arguments - let a single method accept zero, one, or many values of the same type.

You declare them by putting three dots (...) after the parameter type:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {   // numbers is just an int[]
            total += n;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(1, 2, 3));        // 6
        System.out.println(sum(10, 20));         // 30
        System.out.println(sum());               // 0 - zero args is allowed
        System.out.println(sum(4, 8, 15, 16));   // 43
    }
}

The caller passes loose values; inside the method numbers is a real array. That is the whole idea - the compiler bundles the arguments into an array for you.

Varargs Are Just an Array

There is no magic at runtime. A parameter declared int... numbers is exactly an int[] once you are inside the method. You can ask for its length, index into it, and loop over it like any other array.

public class Main {
    static String join(String separator, String... parts) {
        if (parts.length == 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder(parts[0]);
        for (int i = 1; i < parts.length; i++) {
            sb.append(separator).append(parts[i]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println(join("-", "2026", "06", "04"));  // 2026-06-04
        System.out.println(join(", ", "alone"));            // alone
    }
}

Because it is genuinely an array, you can also hand a varargs method an array you already have - it accepts both forms:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) total += n;
        return total;
    }

    public static void main(String[] args) {
        int[] data = {5, 10, 15};
        System.out.println(sum(data));        // pass an existing array
        System.out.println(sum(1, 2, 3, 4));  // or loose values
    }
}

The Rules: Last and Only One

Two rules keep varargs unambiguous, and the compiler enforces both:

1. The varargs parameter must be last. Regular parameters come first, then the ... parameter soaks up whatever is left.
2. A method may have at most one varargs parameter. Two would make it impossible to tell where one ends and the next begins.

public class Main {
    // OK: regular parameter first, varargs last
    static void log(String level, Object... values) {
        System.out.print("[" + level + "] ");
        for (Object v : values) {
            System.out.print(v + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        log("INFO", "user", 42, true);
        log("WARN");   // the varargs part can be empty
    }
}

This compiles. But putting the varargs first - static void log(Object... values, String level) - is a compile error: varargs parameter must be the last. The required parameter level always precedes the ....

Where You Already Use Varargs

You have been calling varargs methods all along. System.out.printf and String.format are the classic examples - their second parameter is Object... args:

public class Main {
    public static void main(String[] args) {
        System.out.printf("%s scored %d points (%.1f%%)%n", "Ada", 95, 95.0);

        String row = String.format("%-8s | %5d", "banana", 30);
        System.out.println(row);
    }
}

List.of(...), Arrays.asList(...), and many builder-style APIs are varargs too. That is why you can pass any number of elements to them without wrapping anything in an array yourself.

Varargs and Overloading

Varargs and overloading interact in one surprising way. When a regular overload and a varargs overload could both match a call, Java prefers the more specific one - the fixed-arity method wins:

public class Main {
    static String pick(int a, int b) {
        return "two-arg version";
    }

    static String pick(int... nums) {
        return "varargs version";
    }

    public static void main(String[] args) {
        System.out.println(pick(1, 2));      // two-arg version (more specific)
        System.out.println(pick(1, 2, 3));   // varargs version
        System.out.println(pick());          // varargs version
    }
}

pick(1, 2) matches both, but Java picks the non-varargs overload because it is the closer fit. The varargs method only runs when no fixed overload matches. This is usually what you want, but it means adding a varargs overload can silently change which method a call resolves to.

Watch the Empty and null Calls

Two gotchas bite people. First, calling a varargs method with no arguments hands the method an empty array, not null - so numbers.length is 0 and looping does nothing. You do not need a null check for the no-argument case:

public class Main {
    static int count(Object... items) {
        return items.length;   // 0 for count(), never an NPE
    }

    public static void main(String[] args) {
        System.out.println(count());            // 0
        System.out.println(count("a", "b"));    // 2
    }
}

Second, passing a literal null is ambiguous and dangerous: Java may interpret count(null) as "the entire varargs array is null" rather than "one null element", which then throws a NullPointerException when you read its length. If you truly mean a single null element, be explicit with count((Object) null).

Next: Classes

Varargs round out what you can do with method parameters - flexible argument lists on top of overloading. So far the methods have lived loosely in a class with static. Next you will see how classes really work: bundling data (fields) and behavior (methods) into your own types, which is the heart of object-oriented Java.