Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Paramètres varargs en Java : String... et T...

En Java SE 21, un paramètre varargs accepte des arguments séparés ou un tableau existant. Avec `T...`, l’effacement de types introduit un risque de pollution du tas.

Version : Java SE 21

Syntaxe

static void labels(String... values) { /* values has type String[] */ }
static <T> int count(T... values) { return values.length; }

En Java SE 21, ... après le type indique un paramètre varargs. Une méthode ou un constructeur ne peut en avoir qu’un, en dernière position. Dans le corps de la méthode, String... values est de type String[] ; dans une méthode générique de paramètre de type <T>, T... values est de type T[].

Lors d’un appel à arité variable, le compilateur fait regrouper les derniers arguments dans un nouveau tableau. labels() reçoit un tableau vide, pas null. Si l’appel est possible sans regroupement, un tableau compatible est transmis sans copie : les modifications de ses éléments sont visibles par l’appelant. Pour la méthode présentée, labels(null) et labels((String[]) null) transmettent une référence de tableau nulle ; lire sa propriété length déclencherait une NullPointerException. labels((String) null) transmet un tableau contenant un seul élément null.

La résolution des surcharges cherche d’abord une méthode applicable sans regroupement : d’abord sans boxing ni unboxing, puis en les autorisant. Le regroupement n’est envisagé que si ces deux phases échouent. Une méthode varargs peut donc être sélectionnée lors d’une phase à arité fixe. labels(String...) et labels(String[]) ont la même signature et ne peuvent pas être deux surcharges distinctes.

String est réifiable : son type est entièrement disponible à l’exécution. T ne l’est pas ; lors du regroupement, le nouveau tableau utilise le type obtenu par effacement du type de tableau déterminé pour l’appel. Le compilateur émet un avertissement unchecked à la déclaration et peut aussi en émettre lors d’un appel. Si le tableau est également référencé comme Object[], une écriture peut enfreindre les garanties des types génériques. Cette pollution du tas peut se manifester plus tard par une ClassCastException à la lecture.

@SafeVarargs est une affirmation de l’auteur, pas un contrôle à l’exécution. L’annotation supprime ces avertissements à la déclaration et aux sites d’appel. Elle est autorisée sur les constructeurs varargs et les méthodes varargs static, final ou private. Ne l’utilisez qu’après avoir vérifié que le tableau n’est ni utilisé ni exposé de façon dangereuse.

Exemples

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

public class VarargsDemo {
    static void labels(String... values) {
        System.out.println(Arrays.toString(values));
    }

    @SafeVarargs
    static <T> int count(T... values) {
        return values.length;
    }

    public static void main(String[] args) {
        labels();
        labels("red", "blue");
        labels(new String[]{"green"});
        labels((String) null);
        labels((String[]) null);
        System.out.println(count(List.of("red", "blue"), List.of("green")));
    }
}

Résultat

[]
[red, blue]
[green]
[null]
null
2

`[]` représente un tableau vide, `[null]` un tableau contenant un seul élément `null`, et `null` l’absence de tableau. `count` lit uniquement la longueur du tableau : il compte deux listes, pas trois chaînes.

Leçons associées

  • Java · Leçon 3 · Avancé · Version : 2
  • Java · Leçon 14 · Avancé · Version : 2

Sources