Java, 3 points dans les paramètres
Que signifient les 3 points dans la méthode suivante?
public void myMethod(String... strings){
// method body
}
Cela signifie que zéro ou plusieurs objets String (ou un tableau d'entre eux) peuvent être passés en tant qu'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 pouvez 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"});
Remarque importante: Le ou les arguments passés de cette manière sont toujours des tableaux, même s'il n'y en a qu'un. Assurez-vous de le traiter de cette manière dans le corps de la méthode.
Remarque importante 2: L'argument qui obtient le ... doit être le dernier dans la signature de la méthode. Donc, myMethod(int i, String... strings) va bien, mais myMethod(String... strings, int i) ne va pas.
Merci à Vash pour les précisions apportées dans son commentaire.
Cette fonctionnalité s'appelle varargs , et c'est une fonctionnalité introduite dans Java 5. Cela signifie que cette fonction peut recevoir plusieurs arguments String:
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 is equivalent to
for( int i = 0; i < strings.length; i++){
// classical for. In this case you use strings[i]
}
}
Cette réponse emprunte énormément aux propos de Kiswa et Lorenzo ... ainsi qu'au commentaire de Graphain.
C'est Varargs:)
Le raccourci varargs pour les arguments de longueur variable est une fonctionnalité qui permet à la méthode d'accepter un nombre variable d'arguments (zéro ou plus). Avec varargs, il est devenu simple de créer des méthodes qui doivent prendre un nombre variable d'arguments. La fonctionnalité d'argument variable a été ajoutée dans Java 5.
Syntaxe de varargs
Un vararg est sécurisé par trois points de suspension (trois points) après le type de données, sa forme générale est
return_type method_name(data_type ... variableName){
}
Besoin de varargs
Avant Java 5, s'il existait un besoin de nombre d'arguments variable, il y avait deux façons de le gérer.
Si le nombre maximal d'arguments qu'une méthode peut prendre est petit et connu, des versions surchargées de la méthode peuvent être créées. Si le nombre maximal d'arguments qu'une méthode pouvait prendre était grand ou/et inconnu, l'approche consistait à les placer dans un tableau et à les transmettre à une méthode qui prend un tableau en paramètre. Ces deux approches étaient sujettes aux erreurs - construction d'un tableau de paramètres à chaque fois et difficile à gérer - car l'ajout d'un nouvel argument pouvait entraîner l'écriture d'une nouvelle méthode surchargée.
Avantages de varargs
Offre une option beaucoup plus simple. Moins de code, pas besoin d'écrire des méthodes surchargées.
Exemple de varargs
public class VarargsExample {
public void displayData(String ... values){
System.out.println("Number of arguments passed " + values.length);
for(String s : values){
System.out.println(s + " ");
}
}
public static void main(String[] args) {
VarargsExample vObj = new VarargsExample();
// four args
vObj.displayData("var", "args", "are", "passed");
//three args
vObj.displayData("Three", "args", "passed");
// no-arg
vObj.displayData();
}
}
Output
Number of arguments passed 4
var
args
are
passed
Number of arguments passed 3
Three
args
passed
Number of arguments passed 0
Le programme indique que la longueur est utilisée ici pour trouver le nombre d'arguments transmis à la méthode. C'est possible parce que les varargs sont implicitement passés en tant que tableau. Quels que soient les arguments passés en tant que varargs, ils sont stockés dans un tableau appelé par le nom donné à varargs. Dans ce programme, le nom du tableau est constitué de valeurs. Notez également que la méthode est appelée avec un nombre d'arguments différent, appelez d'abord avec quatre arguments, puis trois arguments, puis zéro argument. Tous ces appels sont traités par la même méthode qui utilise varargs.
Restriction with varargs
Il est possible d'avoir d'autres paramètres avec le paramètre varargs dans une méthode. Toutefois, dans ce cas, le paramètre varargs doit être le dernier paramètre déclaré par la méthode.
void displayValues(int a, int b, int … values) // OK
void displayValues(int a, int b, int … values, int c) // compiler error
Une autre restriction avec varargs est qu'il ne doit y avoir qu'un seul paramètre varargs.
void displayValues(int a, int b, int … values, int … moreValues) // Compiler error
surcharge des méthodes varargs
Il est possible de surcharger une méthode prenant le paramètre varargs. La méthode Varargs peut être surchargée par -
Les types de son paramètre vararg peuvent être différents. En ajoutant d'autres paramètres. Exemple de surcharge de la méthode varargs
public class OverloadingVarargsExp {
// Method which has string vararg parameter
public void displayData(String ... values){
System.out.println("Number of arguments passed " + values.length);
for(String s : values){
System.out.println(s + " ");
}
}
// Method which has int vararg parameter
public void displayData(int ... values){
System.out.println("Number of arguments passed " + values.length);
for(int i : values){
System.out.println(i + " ");
}
}
// Method with int vararg and one more string parameter
public void displayData(String a, int ... values){
System.out.println(" a " + a);
System.out.println("Number of arguments passed " + values.length);
for(int i : values){
System.out.println(i + " ");
}
}
public static void main(String[] args) {
OverloadingVarargsExp vObj = new OverloadingVarargsExp();
// four string args
vObj.displayData("var", "args", "are", "passed");
// two int args
vObj.displayData(10, 20);
// One String param and two int args
vObj.displayData("Test", 20, 30);
}
}
Output
Number of arguments passed 4
var
args
are
passed
Number of arguments passed 2
10
20
a Test
Number of arguments passed 2
20
30
Varargs et ambiguïté de surcharge
Dans certains cas, l’appel peut être ambigu lorsque la méthode varargs est surchargée. Voyons un exemple
public class OverloadingVarargsExp {
// Method which has string vararg parameter
public void displayData(String ... values){
System.out.println("Number of arguments passed " + values.length);
for(String s : values){
System.out.println(s + " ");
}
}
// Method which has int vararg parameter
public void displayData(int ... values){
System.out.println("Number of arguments passed " + values.length);
for(int i : values){
System.out.println(i + " ");
}
}
public static void main(String[] args) {
OverloadingVarargsExp vObj = new OverloadingVarargsExp();
// four string args
vObj.displayData("var", "args", "are", "passed");
// two int args
vObj.displayData(10, 20);
// This call is ambiguous
vObj.displayData();
}
}
Dans ce programme, lorsque nous appelons la méthode displayData () sans aucun paramètre, une erreur est générée, car le compilateur n'est pas sûr que cet appel de méthode concerne displayData(String ... values) ou displayData(int ... values).
De la même manière, si nous avons des méthodes surchargées où l’on a la méthode vararg d’un type et une autre méthode qui a un paramètre et le paramètre vararg du même type, nous avons aussi l’ambiguïté - As Exp - displayData(int ... values) et displayData(int a, int ... values)
Ces deux méthodes surchargées auront toujours une ambiguïté.
Il s’agit du moyen Java de passer varargs (arguments de nombre variable).
Si vous êtes familier avec C, cela ressemble à la syntaxe ... utilisée par la fonction printf:
int printf(const char * format, ...);
mais de manière sûre: chaque argument doit être conforme au type spécifié (dans votre exemple, ils doivent tous être String).
Voici un exemple simple d'utilisation de 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");
}
}
L'argument ... est en fait un tableau. Vous pouvez donc passer un String[] en tant que paramètre.
On peut soutenir que c'est un exemple de sucre syntaxique, puisqu'il est de toute façon implémenté comme un tableau (ce qui ne veut pas dire que c'est inutile) - je préfère passer un tableau pour le garder clair et aussi déclarer des méthodes avec des tableaux de type donné. Plutôt un avis qu'une réponse, cependant.
Également, il est important de savoir que les paramètres var-arg sont limités à un et que vous ne pouvez pas avoir plusieurs paramètres var-art. Par exemple c'est illigal:
public void myMethod(String... strings, int ... ints){
// method body
}
Pensez-y simplement comme le mot clé params en C #, si vous venez de ce contexte :)
Une façon très courante de voir un exemple clair de l’utilisation des trois points est l’une des méthodes les plus connues de Android AsyncTask (qu’aujourd’hui n’est pas trop utilisé à cause de RXJAVA, sans parler des composants de Google Architecture), vous pouvez trouver des milliers d’exemples qui recherchent ce terme, et le meilleur moyen de comprendre et de ne jamais oublier la signification des trois points est qu’ils expriment un ... doute. .. juste comme dans le langage commun. En d'autres termes, il n'est pas clair que le nombre de paramètres à passer, soit 0, soit 1, pourrait être plus (un tableau) ...
String... est identique à String[]
import Java.lang.*;
public class MyClassTest {
//public static void main(String... args) {
public static void main(String[] args) {
for(String str: args) {
System.out.println(str);
}
}
}