0Pricing
Java Academy · Leçon

Paramètres varargs

Définissez des méthodes qui acceptent des listes d’arguments de longueur variable et combinez-les avec des tableaux.

Paramètres varargs est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Paramètres à nombre variable

Les paramètres à nombre variable permettent de définir des méthodes qui acceptent un nombre quelconque d'arguments du même type, traités en interne comme un tableau.

Déclarer des paramètres à nombre variable

Utilisez Type... name pour un paramètre à nombre variable. Il doit être le dernier paramètre, et une méthode ne peut en contenir qu'un seul.

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

Paramètres à nombre variable en interne

Les paramètres à nombre variable sont du sucre syntaxique. Le compilateur transforme l'appel en création d'un tableau au niveau de l'appel.

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

Paramètres mixtes avec des paramètres à nombre variable

Le paramètre à nombre variable doit être le dernier. Vous pouvez placer des paramètres normaux avant lui.

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

Paramètres à nombre variable avec des types génériques

L'utilisation de paramètres à nombre variable avec des types génériques provoque un avertissement de pollution du tas. Supprimez-le avec @SafeVarargs lorsque la sûreté de la méthode peut être démontrée.

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]

Paramètres à nombre variable et surcharge

Lorsqu'une méthode à nombre variable est surchargée avec une correspondance exacte, cette dernière est privilégiée. Les paramètres à nombre variable ne sont utilisés qu'en dernier recours.

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 utilise des paramètres à nombre variable

System.out.printf utilise des paramètres à nombre variable : la méthode accepte une chaîne de format et un nombre quelconque d'arguments de n'importe quel type.

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

Construire un journaliseur avec des paramètres à nombre variable

Implémentation d'un journaliseur structuré simple qui accepte des paires clé-valeur au moyen de paramètres à nombre variable.

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

Considération relative aux performances

Chaque appel avec des paramètres à nombre variable crée un nouveau tableau sur le tas. Pour les méthodes utilitaires appelées très fréquemment, fournissez des surcharges à arité fixe afin d'éviter cette allocation.

// 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); }

Paramètres à nombre variable et valeur nulle

Passer null à une méthode à nombre variable est ambigu : Java peut l'interpréter comme un tableau nul. Utilisez une conversion explicite pour éviter l'avertissement.

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)

Pratique : utilitaire de formatage de chaînes

Un wrapper sûr de printf qui renvoie la chaîne formatée et utilise des paramètres à nombre variable pour reproduire le style format-arguments.

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' ...]

Vérification rapide

Quel est le type d'un paramètre à nombre variable à l'intérieur du corps de la méthode ?

Récapitulatif : paramètres à nombre variable

Points essentiels :

  • Un paramètre à nombre variable (Type... name) accepte zéro argument ou davantage, traités en interne comme un tableau
  • Il doit être le dernier paramètre, et une méthode ne peut en contenir qu'un seul
  • L'appelant peut transmettre des valeurs individuelles ou un tableau
  • Utilisez @SafeVarargs pour supprimer les avertissements de pollution du tas avec les paramètres à nombre variable génériques
  • Les surcharges à correspondance exacte sont privilégiées par rapport aux surcharges à nombre variable
  • Fournissez des surcharges à arité fixe pour les méthodes fréquemment appelées afin d'éviter l'allocation d'un tableau

Questions Fréquemment Posées

La leçon « Paramètres varargs » est-elle gratuite ?

Oui — le texte complet de « Paramètres varargs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Paramètres varargs » ?

Définissez des méthodes qui acceptent des listes d’arguments de longueur variable et combinez-les avec des tableaux. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Paramètres varargs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Règles de surcharge des méthodes
  2. Paramètres varargs
  3. Champs statiques et constantes
  4. Classes utilitaires et méthodes de fabrique statiques
← Retour à Java Academy