Varargs en Java: métodos que aceptan cualquier número de argumentos

Un método, cualquier número de argumentos

A veces no sabes de antemano cuántos argumentos necesita un método. En un momento quieres max(3, 9) y al siguiente max(1, 7, 4, 2, 8). Sin varargs tendrías que escribir una sobrecarga para cada cantidad u obligar a quien llama a construir un arreglo. Los varargs - abreviatura de argumentos variables - permiten que un solo método acepte cero, uno o muchos valores del mismo tipo.

Se declaran poniendo tres puntos (...) después del tipo del parámetro:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {   // numbers es simplemente un 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 - se permite cero argumentos
        System.out.println(sum(4, 8, 15, 16));   // 43
    }
}

Quien llama pasa valores sueltos; dentro del método numbers es un arreglo real. Esa es toda la idea: el compilador empaqueta los argumentos en un arreglo por ti.

Los varargs son solo un arreglo

No hay magia en tiempo de ejecución. Un parámetro declarado int... numbers es exactamente un int[] una vez que estás dentro del método. Puedes consultar su length, indexarlo y recorrerlo como cualquier otro arreglo.

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
    }
}

Como es realmente un arreglo, también puedes entregarle a un método varargs un arreglo que ya tengas: acepta ambas formas:

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));        // pasa un arreglo existente
        System.out.println(sum(1, 2, 3, 4));  // o valores sueltos
    }
}

Las reglas: último y uno solo

Dos reglas mantienen los varargs sin ambigüedad, y el compilador las hace cumplir ambas:

1. El parámetro varargs debe ser el último. Los parámetros normales van primero, y luego el parámetro ... absorbe todo lo que quede.
2. Un método puede tener como máximo un parámetro varargs. Dos harían imposible saber dónde termina uno y empieza el siguiente.

public class Main {
    // OK: parámetro normal primero, varargs al final
    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");   // la parte de varargs puede estar vacía
    }
}

Esto compila. Pero poner los varargs primero - static void log(Object... values, String level) - es un error de compilación: varargs parameter must be the last. El parámetro obligatorio level siempre precede al ....

Dónde ya usas varargs

Has estado llamando a métodos varargs todo el tiempo. System.out.printf y String.format son los ejemplos clásicos: su segundo parámetro es 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(...) y muchas APIs de estilo constructor también son varargs. Por eso puedes pasarles cualquier número de elementos sin envolver nada en un arreglo tú mismo.

Varargs y sobrecarga

Los varargs y la sobrecarga interactúan de una manera sorprendente. Cuando una sobrecarga normal y una sobrecarga varargs podrían coincidir ambas con una llamada, Java prefiere la más específica: gana el método de aridad fija:

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 (más específica)
        System.out.println(pick(1, 2, 3));   // varargs version
        System.out.println(pick());          // varargs version
    }
}

pick(1, 2) coincide con ambas, pero Java elige la sobrecarga sin varargs porque encaja mejor. El método varargs solo se ejecuta cuando ninguna sobrecarga de aridad fija coincide. Esto suele ser lo que quieres, pero significa que añadir una sobrecarga varargs puede cambiar silenciosamente a qué método se resuelve una llamada.

Cuidado con las llamadas vacías y con null

Dos trampas pillan a la gente. Primera: llamar a un método varargs sin argumentos le entrega al método un arreglo vacío, no null, así que numbers.length es 0 y el bucle no hace nada. No necesitas una comprobación de null para el caso sin argumentos:

public class Main {
    static int count(Object... items) {
        return items.length;   // 0 para count(), nunca una NPE
    }

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

Segunda: pasar un null literal es ambiguo y peligroso: Java puede interpretar count(null) como "todo el arreglo de varargs es null" en lugar de "un elemento null", lo que luego lanza una NullPointerException cuando lees su length. Si realmente quieres decir un único elemento null, sé explícito con count((Object) null).

Siguiente: Clases

Los varargs completan lo que puedes hacer con los parámetros de métodos: listas de argumentos flexibles encima de la sobrecarga. Hasta ahora los métodos han vivido sueltos en una clase con static. A continuación verás cómo funcionan realmente las clases: agrupar datos (campos) y comportamiento (métodos) en tus propios tipos, que es el corazón de la programación orientada a objetos en Java.