Varargs in Java: metodi che accettano un numero qualsiasi di argomenti

Un metodo, un numero qualsiasi di argomenti

A volte non sai in anticipo di quanti argomenti ha bisogno un metodo. Potresti volere max(3, 9) in un momento e max(1, 7, 4, 2, 8) subito dopo. Senza varargs scriveresti un overload per ogni quantità oppure obbligheresti chi chiama a costruire un array. I varargs, abbreviazione di variable arguments (argomenti variabili), permettono a un solo metodo di accettare zero, uno o tanti valori dello stesso tipo.

Li dichiari mettendo tre puntini (...) dopo il tipo del parametro:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {   // numbers è semplicemente 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: zero argomenti è consentito
        System.out.println(sum(4, 8, 15, 16));   // 43
    }
}

Chi chiama passa valori sciolti; dentro il metodo numbers è un vero array. Tutta l'idea è questa: il compilatore raccoglie per te gli argomenti in un array.

I varargs sono solo un array

A runtime non c'è nessuna magia. Un parametro dichiarato int... numbers è esattamente un int[] una volta dentro il metodo. Puoi chiederne la length, accedere agli indici e scorrerlo con un ciclo come qualsiasi altro 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
    }
}

Proprio perché è davvero un array, puoi anche passare a un metodo varargs un array che hai già: accetta entrambe le forme:

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));        // passa un array esistente
        System.out.println(sum(1, 2, 3, 4));  // o valori sciolti
    }
}

Le regole: ultimo e unico

Due regole evitano ambiguità con i varargs, e il compilatore le fa rispettare entrambe:

1. Il parametro varargs deve essere l'ultimo. Prima vengono i parametri normali, poi il parametro ... raccoglie tutto il resto.
2. Un metodo può avere al massimo un parametro varargs. Con due sarebbe impossibile capire dove finisce uno e dove inizia l'altro.

public class Main {
    // OK: prima il parametro normale, varargs per ultimo
    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 varargs può essere vuota
    }
}

Questo compila. Ma mettere i varargs per primi, static void log(Object... values, String level), è un errore di compilazione: varargs parameter must be the last. Il parametro obbligatorio level viene sempre prima del ....

Dove usi già i varargs

Hai sempre chiamato metodi varargs. System.out.printf e String.format sono gli esempi classici: il loro secondo parametro è 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);
    }
}

Anche List.of(...), Arrays.asList(...) e molte API in stile builder usano i varargs. Ecco perché puoi passare loro un numero qualsiasi di elementi senza incapsulare niente in un array.

Varargs e overloading

Varargs e overloading interagiscono in un modo sorprendente. Quando sia un overload normale sia un overload varargs potrebbero corrispondere a una chiamata, Java preferisce quello più specifico: vince il metodo con un numero fisso di parametri:

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 (più specifica)
        System.out.println(pick(1, 2, 3));   // varargs version
        System.out.println(pick());          // varargs version
    }
}

pick(1, 2) corrisponde a entrambi, ma Java sceglie l'overload senza varargs perché è quello più adatto. Il metodo varargs viene eseguito solo quando nessun overload fisso corrisponde. Di solito è ciò che vuoi, ma significa che aggiungere un overload varargs può cambiare in silenzio il metodo scelto da una chiamata.

Attenzione alle chiamate vuote e a null

Due trappole colpiscono spesso. La prima: chiamare un metodo varargs senza argomenti gli passa un array vuoto, non null, quindi numbers.length vale 0 e il ciclo non fa niente. Non ti serve un controllo su null per il caso senza argomenti:

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

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

La seconda: passare un null letterale è ambiguo e pericoloso. Java può interpretare count(null) come "l'intero array varargs è null" invece che "un elemento null", e questo lancia una NullPointerException quando leggi la sua length. Se intendi davvero un singolo elemento null, sii esplicito con count((Object) null).

Prossima pagina: classi

I varargs completano ciò che puoi fare con i parametri dei metodi: liste di argomenti flessibili in aggiunta all'overloading. Finora i metodi sono rimasti sparsi in una classe con static. Ora vedrai come funzionano davvero le classi: raggruppare dati (campi) e comportamento (metodi) in tipi tutti tuoi, il cuore della programmazione a oggetti in Java.