Was bedeuten die 3 Punkte neben einem Parametertyp in Java?

Question

Was bedeuten die folgenden 3 Punkte String in der folgenden Methode bedeuten?

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

Answer 1

Es bedeutet, dass null oder mehr String-Objekte (oder ein einzelnes Array davon) als Argument(e) für diese Methode übergeben werden können.

Siehe den Abschnitt "Beliebige Anzahl von Argumenten" hier: http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs

In Ihrem Beispiel könnten Sie es als eine der folgenden Möglichkeiten aufrufen:

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

Wichtiger Hinweis: Das/die auf diese Weise übergebene(n) Argument(e) ist/sind immer ein Array - auch wenn es nur eines ist. Stellen Sie sicher, dass Sie es im Methodenrumpf auch so behandeln.

Wichtige Anmerkung 2: Das Argument, das die ... muss die letzte in der Methodensignatur sein. Also, myMethod(int i, String... strings) ist in Ordnung, aber myMethod(String... strings, int i) ist nicht in Ordnung.

Vielen Dank an Vash für die Klarstellungen in seinem Kommentar.

Answer 2

Dieses Merkmal wird als varargs und es ist eine Funktion, die in Java 5 eingeführt wurde. Es bedeutet, dass eine Funktion mehrere String Argumente:

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

Dann können Sie die String var als Array:

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]
    }
}

Diese Antwort lehnt sich stark an die von kiswa und Lorenzo an... und auch an den Kommentar von Graphain.

Answer 3

Es ist Varargs :)

Das varargs-Kürzel für Argumente variabler Länge ist eine Funktion, die es der Methode erlaubt, eine variable Anzahl von Argumenten (null oder mehr) zu akzeptieren. Mit varargs ist es einfach geworden, Methoden zu erstellen, die eine variable Anzahl von Argumenten annehmen müssen. Die Funktion der variablen Argumente wurde in Java 5 hinzugefügt.

Syntax von varargs

Ein vararg wird durch drei Ellipsen (drei Punkte) nach dem Datentyp abgegrenzt, seine allgemeine Form ist

return_type method_name(data_type ... variableName){
}  

Bedarf an varargs

Vor Java 5 gab es für den Fall, dass eine variable Anzahl von Argumenten benötigt wurde, zwei Möglichkeiten, diese zu behandeln

Wenn die maximale Anzahl von Argumenten, die eine Methode annehmen kann, klein und bekannt war, dann konnten überladene Versionen der Methode erstellt werden. Wenn die maximale Anzahl von Argumenten, die eine Methode aufnehmen kann, groß oder/und unbekannt war, dann war der Ansatz, diese Argumente in ein Array zu packen und sie an eine Methode zu übergeben, die das Array als Parameter nimmt. Diese beiden Ansätze waren fehleranfällig - jedes Mal wurde ein Array mit Parametern erstellt - und schwer zu pflegen, da das Hinzufügen eines neuen Arguments zum Schreiben einer neuen überladenen Methode führen konnte.

Vorteile von varargs

Bietet eine viel einfachere Option. Weniger Code, da keine überladenen Methoden geschrieben werden müssen.

Beispiel für 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

Aus dem Programm ist ersichtlich, dass length hier verwendet wird, um die Anzahl der an die Methode übergebenen Argumente zu ermitteln. Dies ist möglich, weil varargs implizit als Array übergeben werden. Alle Argumente, die als varargs übergeben werden, werden in einem Array gespeichert, das durch den Namen, der varargs gegeben wird, bezeichnet wird. In diesem Programm ist der Name des Arrays values. Beachten Sie auch, dass die Methode mit einer unterschiedlichen Anzahl von Argumenten aufgerufen wird, zuerst mit vier Argumenten, dann mit drei Argumenten und dann mit null Argumenten. Alle diese Aufrufe werden von der gleichen Methode verarbeitet, die varargs entgegennimmt.

Einschränkung mit varargs

Es ist möglich, andere Parameter mit varargs-Parameter in einer Methode zu haben, aber in diesem Fall muss varargs-Parameter der letzte von der Methode deklarierte Parameter sein.

void displayValues(int a, int b, int … values) // OK
   void displayValues(int a, int b, int … values, int c) // compiler error

Eine weitere Einschränkung bei varargs ist, dass es nur einen varargs-Parameter geben darf.

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

Überladen von varargs-Methoden

Es ist möglich, eine Methode zu überladen, die varargs-Parameter annimmt. Die Varargs-Methode kann überladen werden durch -

Die Typen der vararg-Parameter können unterschiedlich sein. Durch Hinzufügen weiterer Parameter. Beispiel für das Überladen der varargs-Methode

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 und Überladungsmehrdeutigkeit

In einigen Fällen kann der Aufruf zweideutig sein, während wir die varargs-Methode überladen haben. Hier ein Beispiel

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();
 }
}

Wenn wir in diesem Programm die Methode displayData() ohne Parameter aufrufen, wird ein Fehler ausgelöst, da der Compiler nicht sicher ist, ob dieser Methodenaufruf für displayData(String ... values) o displayData(int ... values)

Das Gleiche gilt, wenn wir überladene Methoden haben, von denen eine die vararg Methode eines Typs und eine andere Methode hat einen Parameter und vararg Parameter des gleichen Typs, dann haben wir auch die Zweideutigkeit - Als Exp - displayData(int ... values) y displayData(int a, int ... values)

Diese beiden überladenen Methoden werden immer zweideutig sein.

Answer 4

Dies ist der Java-Weg zur Übergabe varargs (variable Anzahl von Argumenten).

Wenn Sie mit C vertraut sind, ist dies ähnlich wie die ... Syntax verwendet es die printf Funktion:

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

aber auf eine typsichere Weise: jedes Argument muss dem angegebenen Typ entsprechen (in Ihrem Beispiel sollten sie alle String ).

Dies ist ein einfaches Beispiel dafür, wie Sie Folgendes verwenden können 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");
   }
}

En ... Argument ist eigentlich ein Array, Sie könnten also eine String[] als Parameter.

Answer 5

Es ist wohl ein Beispiel für syntaktischen Zucker, da es ohnehin als Array implementiert ist (was nicht bedeutet, dass es nutzlos ist) - ich bevorzuge die Übergabe eines Arrays, um es übersichtlich zu halten, und deklariere auch Methoden mit Arrays eines bestimmten Typs. Das ist allerdings eher eine Meinung als eine Antwort.