Que signifient les 3 points à côté d'un type de paramètre en Java ?

Question

Que signifient les 3 points suivants String dans la méthode suivante ?

public void myMethod(String... strings){
    // method body
}

Answer 1

Cela signifie que zéro ou plusieurs objets String (ou un seul tableau de ceux-ci) peuvent être passés comme argument(s) pour cette méthode.

Voir la section "Nombre arbitraire d'arguments" ici : http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs

Dans votre exemple, vous pourriez l'appeler de l'une des manières suivantes :

myMethod(); // Likely useless, but possible
myMethod("one", "two", "three");
myMethod("solo");
myMethod(new String[]{"a", "b", "c"});

Note importante : Le ou les arguments passés de cette manière sont toujours un tableau - même s'il n'y en a qu'un seul. Assurez-vous de le traiter de cette façon dans le corps de la méthode.

Note importante 2 : L'argument qui obtient le ... doit être le dernier de la signature de la méthode. Donc, myMethod(int i, String... strings) c'est bon, mais myMethod(String... strings, int i) n'est pas acceptable.

Merci à Vash pour les précisions apportées dans son commentaire.

Answer 2

Cette fonction est appelée varargs Il s'agit d'une fonctionnalité introduite dans Java 5. Cela signifie que la fonction peut recevoir plusieurs String arguments :

myMethod("foo", "bar");
myMethod("foo", "bar", "baz");
myMethod(new String[]{"foo", "var", "baz"}); // you can even pass an array

Ensuite, vous pouvez utiliser le String var comme un tableau :

public void myMethod(String... strings){
    for(String whatever : strings){
        // do what ever you want
    }

    // the code above is equivalent to
    for( int i = 0; i < strings.length; i++){
        // classical for. In this case you use strings[i]
    }
}

Cette réponse emprunte beaucoup à celles de kiswa et de Lorenzo... et aussi au commentaire de Graphain.

Answer 3

C'est la façon Java de passer varargs (arguments à nombre variable).

Si vous êtes familier avec le langage C, ceci est similaire à la fonction ... syntaxe utilisée dans le printf fonction :

int printf(const char * format, ...);

mais d'une manière sûre : chaque argument doit être conforme au type spécifié (dans votre exemple, ils devraient être tous des String ).

Il s'agit d'un simple exemple de la manière dont vous pouvez utiliser varargs :

class VarargSample {

   public static void PrintMultipleStrings(String... strings) {
      for( String s : strings ) {
          System.out.println(s);
      }
   }

   public static void main(String[] args) {
      PrintMultipleStrings("Hello", "world");
   }
}

El ... est en fait un tableau, de sorte que vous pouvez passer un fichier String[] comme paramètre.

Answer 4

On peut dire que c'est un exemple de sucre syntaxique, puisqu'il est implémenté comme un tableau de toute façon (ce qui ne veut pas dire qu'il est inutile) - je préfère passer un tableau pour que ce soit clair, et aussi déclarer des méthodes avec des tableaux de type donné. C'est plutôt une opinion qu'une réponse, cependant.

Answer 5

Pensez-y comme le mot-clé params en C#, si vous venez de ce milieu :)