Puis-je transmettre un tableau comme arguments à une méthode avec des arguments variables en java?

Dans java, méthodes d'arity de variable (méthodes avec des arguments variables) utilisent un elipsiSis (...) pour indiquer que la méthode accepte un numéro varable d'arguments. Lorsque vous passez un tableau à une méthode d'arité variable, les éléments du tableau sont traités comme des arguments individuels à cette méthode.

Considérez le code suivant:

class A {
  private String extraVar;

  public String myFormat(String format, Object... args) {
    return String.format(format, extraVar, args);
  }
}

Dans cet exemple, la méthode MyFormat prend un nombre variable d'arguments (représenté par le ... args) et formats une chaîne à l'aide de la méthode string.format. La question est que les args sont traités comme un seul objet [] un tableau, plutôt que comme des arguments individuels. Pour résoudre ce problème, vous pouvez tirer parti du fait qu'un T ... est un sucre syntaxique pour un t [].

Spécification du langage Java 8.4.1 États:

"Si le dernier paramètre formel est un paramètre Arity variable de type T, il est considéré pour définir un paramètre formel de type T []. La méthode est alors une méthode artifiée variable. illustrer cela, l'extrait de code suivant montre comment passer un tableau comme arguments à une méthode d'arity variable:

String statique public ezformat (objet ... args) { String format = new String (new char [args.length]). Remplace ("\ 0", "[% s]"); return String.format (format, args); } public static void main (String ... args) { System.out.println (ezformat ("a", "b", "c")); // imprime "[a] [b] [c]" }

public static String ezFormat(Object... args) {
    String format = new String(new char[args.length]).replace("\0", "[ %s ]");
    return String.format(format, args);
}

public static void main(String... args) {
    System.out.println(ezFormat("A", "B", "C")); // prints "[ A ][ B ][ C ]"
}

méthode d'aripie variable gotchas

passant des valeurs nulles

lors de la transmission des valeurs nulles à une méthode Arity variable, il est important de savoir que la dernière instruction dans l'exemple suivant: &&& Chyth, il est important de savoir que le static est important pour savoir que la dernière instruction dans l'exemple suivant: &&& Chy. VOID COUNT (objet ... objs) { System.out.println (Objs.Length); } comte (null, null, null); // imprime "3" Count (null, null); // imprime "2" compter (null); // lève java.lang.nullpointerException !!!

... se traduira par une nullpointerException. Pour éviter cela, vous pouvez transmettre l'argument null en tant que tableau séparé ou comme un objet, comme ceci:

static void count(Object... objs) {
    System.out.println(objs.length);
}

count(null, null, null); // prints "3"
count(null, null); // prints "2"
count(null); // throws java.lang.NullPointerException!!!

ajoutant des arguments supplémentaires

count(new Object[] { null }); // prints "1"
count((Object) null); // prints "1"

Passage des tableaux de primitives

Méthodes d'arity variables ne fonctionnent qu'avec des types de référence. L'autoboxing ne s'applique pas aux tableaux de primitifs. Pour passer un tableau de primitives, vous devez d'abord les convertir en un tableau de leur type de wrapper:

static  T[] append(T[] arr, T lastElement) {
    final int N = arr.length;
    arr = java.util.Arrays.copyOf(arr, N 1);
    arr[N] = lastElement;
    return arr;
}

static  T[] prepend(T[] arr, T firstElement) {
    final int N = arr.length;
    arr = java.util.Arrays.copyOf(arr, N 1);
    System.arraycopy(arr, 0, arr, 1, N);
    arr[0] = firstElement;
    return arr;
}