Question Java, 3 points dans les paramètres


Que signifient les 3 points de la méthode suivante?

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

662
2017-07-01 14:27


origine


Réponses:


Cela signifie que zéro ou plusieurs objets String (ou un tableau d'entre eux) peuvent être transmis 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 comme suit:

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

Note importante: Le (s) argument (s) transmis de cette manière est toujours un tableau - même s'il n'y en a qu'un. 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 dans la signature de la méthode. Alors, myMethod(int i, String... strings) c'est bon, mais myMethod(String... strings, int i) ça ne va pas.

Merci à Vash pour les clarifications dans son commentaire.


809
2017-07-01 14:32



Cette fonctionnalité est appelée Varargs, et c'est 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 en 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 beaucoup à celle de Kiswa et de Lorenzo ... et aussi au commentaire de Graphain.


101
2017-07-01 14:30



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

Si vous connaissez C, cela ressemble à la ... la syntaxe l'a utilisé printf fonction:

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

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

Ceci est un exemple simple de la façon 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");
   }
}

le ... argument est en fait un tableau, de sorte que vous pourriez passer un String[] en tant que paramètre


12
2017-07-01 14:38



On peut dire qu'il s'agit d'un exemple de sucre syntaxique, car il est implémenté comme un tableau (ce qui ne veut pas dire qu'il est inutile) - je préfère passer un tableau pour le rendre clair, et déclarer des méthodes avec des tableaux de type donné. Plutôt une opinion qu'une réponse, cependant.


10
2018-05-11 10:35



C'est Varargs  :)

La variable 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 caractéristique de l'argument variable a été ajoutée dans Java 5.

Syntaxe de varargs

Une vararg est sécurisée par trois ellipses (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, au cas où il y aurait un besoin d'un nombre variable d'arguments, il y avait deux façons de le gérer

Si le nombre maximum d'arguments qu'une méthode peut prendre était petit et connu, des versions surchargées de la méthode pourraient être créées. Si le nombre maximal d'arguments qu'une méthode pouvait prendre était grand ou / et inconnu, l'approche consistait à placer ces arguments dans un tableau et à les passer à une méthode qui prend array comme paramètre. Ces deux approches étaient sujettes aux erreurs - construire un tableau de paramètres à chaque fois et difficile à maintenir - car l'ajout d'un nouvel argument peut entraîner l'écriture d'une nouvelle méthode surchargée.

Les avantages de varargs

Offre une option beaucoup plus simple. Moins de code car 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

Il peut être vu à partir du programme que la longueur est utilisée ici pour trouver le nombre d'arguments passés à la méthode. C'est possible parce que les varargs sont implicitement transmis en tant que tableau. Quels que soient les arguments passés en tant que varargs, ils sont stockés dans un tableau référencé par le nom donné à varargs. Dans ce programme, le nom du tableau est des valeurs. Notez également que la méthode est appelée avec un nombre différent d'arguments, un premier appel avec quatre arguments, puis trois arguments et ensuite avec zéro argument. Tous ces appels sont traités par la même méthode qui prend varargs.

Restriction avec varargs

Il est possible d'avoir d'autres paramètres avec le paramètre varargs dans une méthode, mais 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 doit y avoir un seul paramètre varargs.

void displayValues(int a, int b, int … values, int … moreValues) // Compiler error

Overloading Varargs Méthodes

Il est possible de surcharger une méthode qui prend le paramètre varargs. La méthode de 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 méthode Varargs de surcharge

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 nous avons surchargé la méthode varargs. Voyons voir 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, elle génère une erreur, car le compilateur ne sait pas si cet appel de méthode est destiné à displayData(String ... values) ou displayData(int ... values)

De même si nous avons surchargé les méthodes où l'on a le vararg méthode d'un type et une autre méthode a un paramètre et vararg paramètre du même type, alors aussi nous avons l'ambiguïté - Comme Exp - displayData(int ... values) et displayData(int a, int ... values)

Ces deux méthodes surchargées auront toujours une ambiguïté.


8
2018-01-30 04:50



Aussi pour faire la lumière, 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 ceci est illigal:

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

4
2018-01-05 17:06



Pensez-y simplement en tant que mot-clé params en C #, si vous venez de cet arrière-plan :)


3
2018-06-29 05:35



String... est le même que 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);

        }
        }
        }

2
2017-09-19 17:44