Java, 3 puntos en los parámetros

Question

¿Qué significan los 3 puntos en el siguiente método?

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

Answer 1

Significa que se pueden pasar cero o más objetos String (o una matriz de ellos) como argumento (s) para ese método.

Véase la "arbitraria número de argumentos" sección aquí: http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs

En su ejemplo, se le puede llamar como cualquiera de los siguientes:

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

Nota Importante: El argumento (s) pasado de esta manera siempre es una matriz, incluso si solo hay una. Asegúrate de tratarlo de esa manera en el cuerpo del método.

Nota importante 2: El argumento que obtiene el ... 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 está bien.

Gracias a Vash por las aclaraciones en su comentario.

Answer 2

Esa característica se llama varargs, y es una característica introducida en Java 5. Esto 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 

A continuación, puede utilizar la String var como una matriz :

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

Esta respuesta inspira en gran medida a partir de kiswa y Lorenzo ... y también de la observación de la Graphain.

Answer 3

Esta es la forma de Java para pasar varargs (argumentos de número de variable).

Si está familiarizado con C, esto es similar a la sintaxis ... utilizado la función printf:

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

pero de una manera segura tipo: todos los argumentos que tiene que cumplir con el tipo especificado (en su muestra, deben ser todos String).

Ésta es una simple muestra de cómo se puede utilizar 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 argumento ... es en realidad una matriz, por lo que podría pasar una String[] como parámetro.

Answer 4

Podría decirse que es un ejemplo de azúcar sintáctica, ya que se implementa como una matriz de todos modos (lo que no significa que sea inútil) - Prefiero pasar una matriz para mantenerlo claro, y también declarar métodos con matrices de tipo. Más bien una opinión que una respuesta, sin embargo.

Answer 5

Sólo pensar en ella como la palabra clave params en C#, si viene de ese fondo :)

Answer 6

Una forma muy común ver un claro ejemplo de la utilización de los tres puntos que está presente en uno de Los métodos más famosos en Android AsyncTask (que hoy no se usan demasiado debido a RXJAVA, por no mencionar los componentes de la Arquitectura de Google), puedes encontrar miles de ejemplos buscando este término, y la mejor manera de entender y nunca olvidar el El significado de los tres puntos es que expresan una ... duda ... como en el lenguaje común. A saber, no está claro el número de parámetros que deben pasarse, podría ser 0, podría ser 1 podría ser más (una matriz) ...

Answer 7

También para arrojar algo de luz, es importante saber que var Los parámetros arg están limitados a uno y no se pueden tener varios parámetros var-art. Por ejemplo esto es illigal:

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

Answer 8

Es Varargs:)

El varargs corto para argumentos de longitud variable es una característica que permite que el método para aceptar número variable de argumentos (cero o más) Con varargs se ha vuelto simple crear métodos que necesitan tomar una cantidad variable de argumentos. La función de argumentos variable se ha añadido en Java 5.

Sintaxis de varargs

A vararg se secified por tres puntos suspensivos (tres puntos) después de que el 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 existía la necesidad de un número variable de argumentos, había dos formas de manejarlo

Si la cantidad máxima de argumentos que puede tomar un método es pequeña y conocida, se podrían crear versiones sobrecargadas del método. Si el número máximo de argumentos que un método puede tomar es grande o desconocido, el enfoque fue poner esos argumentos en una matriz y pasarlos a un método que toma la matriz como un parámetro. Estos 2 enfoques eran propensos a errores: la construcción de una matriz de parámetros cada vez y difíciles de mantener, ya que la adición de un nuevo argumento puede dar como resultado la escritura de un nuevo método sobrecargado.

Ventajas de varargs

ofrece una opción mucho más simple. 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 desde el programa que se utiliza la longitud aquí para encontrar el número de argumentos pasados ​​al método. Es posible porque varargs se pasan implícitamente como una matriz. Cualquier argumento que se pase como varargs se almacena en una matriz a la que se hace referencia por 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 diferente número de argumentos, primera llamada con cuatro argumentos, luego tres argumentos y luego con cero argumentos. Todas estas llamadas son manejadas por el mismo método que toma varargs.

Restricción con varargs

Es posible tener otros parámetros con los parámetros varargs en un método, sin embargo, en ese caso, varargs parámetro 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 varargs Métodos

Es posible sobrecargar un método que toma varargs parámetro. El método de Varargs se puede sobrecargar por -

Los tipos de su parámetro vararg pueden ser diferentes. Agregando otros parámetros. Ejemplo de sobrecarga varargs método

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 la sobrecarga ambigüedad

En algunos casos, la llamada puede ser ambiguo, mientras que hemos sobrecargado varargs método. 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 se hace una llamada al método sin ningún parámetro que arroja error displayData(), ya que el compilador no está seguro de si este llamado método es para displayData(String ... values) o displayData(int ... values)

la misma manera si hemos sobrecargado métodos donde se tiene el método de un tipo vararg 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.

Answer 9

String... es lo mismo 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); 

     } 
     } 
     }