Solución:
Significa que cero o más objetos String (o una sola matriz de ellos) pueden pasarse como argumento (s) para ese método.
Consulte la sección “Número arbitrario de argumentos” aquí: http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs
En su ejemplo, podría llamarlo como cualquiera de los siguientes:
myMethod(); // Likely useless, but possible
myMethod("one", "two", "three");
myMethod("solo");
myMethod(new String[]{"a", "b", "c"});
Nota IMPORTANTE: Los argumentos que se pasan de esta manera siempre son una matriz, incluso si solo hay uno. Asegúrese de tratarlo de esa manera en el cuerpo del método.
Nota importante 2: El argumento que obtiene la ... debe ser el último en la firma del método. Entonces, myMethod(int i, String... strings) está bien, pero myMethod(String... strings, int i) no esta bien.
Gracias a Vash por las aclaraciones en su comentario.
Esa característica se llama varargs y es una característica introducida en Java 5. Significa que la función puede recibir múltiples String argumentos:
myMethod("foo", "bar");
myMethod("foo", "bar", "baz");
myMethod(new String[]{"foo", "var", "baz"}); // you can even pass an array
Entonces, puede usar el String var como una matriz:
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]
}
}
Esta respuesta toma prestada en gran medida de los de kiswa y Lorenzo … y también del comentario de Graphain.
Son varargs 🙂
La abreviatura de varargs para argumentos de longitud variable es una característica que permite que el método acepte un número variable de argumentos (cero o más). Con varargs se ha vuelto sencillo crear métodos que necesitan tomar un número variable de argumentos. La función de argumento variable se ha agregado en Java 5.
Sintaxis de varargs
Un vararg se secifica con tres puntos suspensivos (tres puntos) después del tipo de datos, su forma general es
return_type method_name(data_type ... variableName){
}
Necesidad de varargs
Antes de Java 5, en caso de que se necesitara un número variable de argumentos, había dos formas de manejarlo
Si el número máximo de argumentos que puede tomar un método es pequeño y conocido, se pueden crear versiones sobrecargadas del método. Si el número máximo de argumentos que podía tomar un método era grande o desconocido, entonces el enfoque era poner esos argumentos en una matriz y pasarlos a un método que toma una matriz como parámetro. Estos 2 enfoques eran propensos a errores, construían una matriz de parámetros cada vez y eran difíciles de mantener, ya que la adición de un nuevo argumento puede resultar en la escritura de un nuevo método sobrecargado.
Ventajas de los varargs
Ofrece una opción mucho más sencilla. Menos código ya que no es necesario escribir métodos sobrecargados.
Ejemplo 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
Se puede ver en el programa que la longitud se usa aquí para encontrar el número de argumentos pasados al método. Es posible porque los varargs se pasan implícitamente como una matriz. Los argumentos que se pasan como varargs se almacenan en una matriz a la que se hace referencia con el nombre dado a varargs. En este programa, el nombre de la matriz es valores. También tenga en cuenta que se llama al método con un número diferente de argumentos, primero se llama con cuatro argumentos, luego con tres argumentos y luego con cero argumentos. Todas estas llamadas se manejan con el mismo método que toma varargs.
Restricción con varargs
Es posible tener otros parámetros con el parámetro varargs en un método, sin embargo, en ese caso, el parámetro varargs debe ser el último parámetro declarado por el método.
void displayValues(int a, int b, int … values) // OK
void displayValues(int a, int b, int … values, int c) // compiler error
Otra restricción con varargs es que debe haber solo un parámetro varargs.
void displayValues(int a, int b, int … values, int … moreValues) // Compiler error
Sobrecarga de métodos de varargs
Es posible sobrecargar un método que toma el parámetro varargs. El método Varargs puede ser sobrecargado por:
Los tipos de su parámetro vararg pueden ser diferentes. Añadiendo otros parámetros. Ejemplo de método de sobrecarga de 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 y ambigüedad sobrecargada
En algunos casos, la llamada puede ser ambigua mientras tenemos el método varargs sobrecargado. Veamos un ejemplo
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();
}
}
En este programa, cuando hacemos una llamada al método displayData () sin ningún parámetro, arroja un error, porque el compilador no está seguro de si esta llamada al método es para displayData(String ... values) o displayData(int ... values)
De la misma manera si tenemos métodos sobrecargados donde uno tiene el vararg método de un tipo y otro método tiene un parámetro y vararg parámetro del mismo tipo, entonces también tenemos la ambigüedad – Como Exp –
displayData(int ... values) y displayData(int a, int ... values)
Estos dos métodos sobrecargados siempre tendrán ambigüedad.