0Pricing
Java Academy · Lezione

Parametri varargs

Definisca metodi che accettano liste di argomenti a lunghezza variabile e le combini con gli array.

Parametri varargs è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Parametri varargs

I varargs (liste di argomenti a lunghezza variabile) consentono di definire metodi che accettano un numero qualsiasi di argomenti dello stesso tipo, trattati internamente come un array.

Dichiarazione dei varargs

Utilizzi Type... name per un parametro varargs. Deve essere l'ultimo parametro e può essercene soltanto uno per metodo.

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

System.out.println(sum());           // 0 (empty array)
System.out.println(sum(1));          // 1
System.out.println(sum(1, 2, 3));    // 6
System.out.println(sum(1, 2, 3, 4)); // 10

// Can also pass an array
int[] arr = {5, 10, 15};
System.out.println(sum(arr));        // 30

I varargs internamente

I varargs sono zucchero sintattico. Il compilatore trasforma la chiamata nella creazione di un array nel punto della chiamata.

// Calling: sum(1, 2, 3)
// Compiler generates: sum(new int[]{1, 2, 3})

static void printAll(String label, String... items) {
    System.out.println(label + ":");
    for (String item : items) System.out.println("  - " + item);
}

printAll("Fruits", "Apple", "Banana", "Cherry");
// Fruits:
//   - Apple
//   - Banana
//   - Cherry

printAll("Empty"); // varargs is empty array

Parametri misti con i varargs

Il parametro varargs deve essere l'ultimo. Prima di esso è possibile combinare parametri normali.

static double average(String label, double... values) {
    if (values.length == 0) return 0.0;
    double sum = 0;
    for (double v : values) sum += v;
    double avg = sum / values.length;
    System.out.printf("%s average: %.2f%n", label, avg);
    return avg;
}

average("Math scores", 92.0, 85.5, 78.0, 95.0);
// Math scores average: 87.62

average("Single value", 100.0);
// Single value average: 100.00

Varargs con tipi generici

L'uso dei varargs con i generics genera un avviso di heap pollution. Lo sopprima con @SafeVarargs quando il metodo è certamente sicuro.

import java.util.Arrays;
import java.util.List;

@SafeVarargs  // suppresses heap pollution warning
static <T> List<T> listOf(T... elements) {
    return Arrays.asList(elements); // safe: we don't store to the array
}

List<String> names = listOf("Alice", "Bob", "Charlie");
System.out.println(names); // [Alice, Bob, Charlie]

List<Integer> scores = listOf(95, 87, 73);
System.out.println(scores); // [95, 87, 73]

Varargs e sovraccarico

Quando un metodo varargs è sovraccaricato con una corrispondenza esatta, viene preferita la corrispondenza esatta. I varargs sono l'ultima risorsa.

static void log(String msg)         { System.out.println("1-arg: " + msg); }
static void log(String m1, String m2) { System.out.println("2-arg: " + m1 + ", " + m2); }
static void log(String... msgs)        { System.out.println("varargs: " + msgs.length); }

log("hello");          // 1-arg: hello
log("a", "b");         // 2-arg: a, b
log("a", "b", "c");   // varargs: 3
log();                  // varargs: 0

printf usa i varargs

System.out.printf usa i varargs: accetta una stringa di formato e un numero qualsiasi di argomenti di qualsiasi tipo.

// printf signature: printf(String format, Object... args)
System.out.printf("%s ordered %d items for $%.2f%n",
    "Alice", 3, 59.97);
// Alice ordered 3 items for $59.97

// String.format is also varargs
String msg = String.format("Error %d: %s", 404, "Not Found");
System.out.println(msg); // Error 404: Not Found

Creazione di un logger con i varargs

Implementazione di un semplice logger strutturato che accetta coppie chiave-valore tramite varargs.

static void logEvent(String event, Object... keyValues) {
    if (keyValues.length % 2 != 0)
        throw new IllegalArgumentException("Key-value pairs required");
    StringBuilder sb = new StringBuilder(event);
    for (int i = 0; i < keyValues.length; i += 2)
        sb.append(" ").append(keyValues[i]).append("=").append(keyValues[i+1]);
    System.out.println(sb);
}

logEvent("user.login",  "userId", 42, "ip", "192.168.1.1", "success", true);
// user.login userId=42 ip=192.168.1.1 success=true

Considerazioni sulle prestazioni

Ogni chiamata con varargs crea un nuovo array nell'heap. Per i metodi di utilità chiamati frequentemente, fornisca sovraccarichi con arità fissa per evitare l'allocazione.

// Java's own EnumSet does this:
static <E extends Enum<E>> EnumSet<E> of(E e)              { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2)       { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3) { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E... rest)  { ... }
// Avoids array creation for 1-3 args (most common case)

// Apply the same pattern to your own hot-path APIs:
static void report(String msg)             { log(new String[]{msg}); }
static void report(String m1, String m2)   { log(new String[]{m1, m2}); }
static void report(String... msgs)         { log(msgs); }

Varargs e null

Passare null a un metodo varargs è ambiguo: Java può interpretarlo come un array null. Utilizzi un cast esplicito per evitare l'avviso.

static void printItems(String... items) {
    if (items == null) {
        System.out.println("null array passed");
        return;
    }
    for (String item : items)
        System.out.println(item != null ? item : "(null element)");
}

printItems((String[]) null); // null array passed
printItems(null, "valid");   // (null element), valid
printItems();                 // empty array (0 items)

Pratica: helper di formattazione di String

Un wrapper sicuro per printf che restituisce la stringa formattata, usando i varargs per riprodurre lo stile format-args.

static String fmt(String pattern, Object... args) {
    try {
        return String.format(pattern, args);
    } catch (java.util.IllegalFormatException e) {
        return "[FORMAT ERROR: " + e.getMessage() + "]";
    }
}

System.out.println(fmt("User %s has %d orders", "Alice", 5));
// User Alice has 5 orders

System.out.println(fmt("Invalid %z format", "arg"));
// [FORMAT ERROR: Conversion = 'z' ...]

Verifica rapida

Qual è il tipo di un parametro varargs all'interno del corpo del metodo?

Riepilogo: parametri varargs

Punti chiave:

  • Varargs (Type... name) accetta 0 o più argomenti, trattati internamente come un array
  • Deve essere l'ultimo parametro: può esserci un solo parametro varargs per metodo
  • Il chiamante può passare singoli valori oppure un array
  • Utilizzi @SafeVarargs per sopprimere gli avvisi di heap pollution relativi ai varargs generici
  • Gli overload con corrispondenza esatta sono preferiti agli overload varargs
  • Fornisca overload con arità fissa per i metodi chiamati frequentemente, così da evitare l'allocazione di array

Domande Frequenti

La lezione «Parametri varargs» è gratuita?

Sì — il testo completo di «Parametri varargs» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Parametri varargs»?

Definisca metodi che accettano liste di argomenti a lunghezza variabile e le combini con gli array. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Parametri varargs»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Regole dell'overloading dei metodi
  2. Parametri varargs
  3. Campi statici e costanti
  4. Classi di utilità e metodi factory statici
← Torna a Java Academy