example - table swing java
Java, 3 puntos en parámetros (9)
¿Qué significan los 3 puntos en el siguiente método?
public void myMethod(String... strings){
// method body
}
Esa característica se llama http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs y es una característica introducida en Java 5. Esto significa que la función puede recibir múltiples argumentos de String :
myMethod("foo", "bar");
myMethod("foo", "bar", "baz");
myMethod(new String[]{"foo", "var", "baz"}); // you can even pass an array
Luego, puedes usar la var. String 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 se basa en gran medida en las de Kiswa y Lorenzo ... y también en el comentario de Graphain.
Esta es la forma en Java de pasar varargs (argumentos de número variable).
Si está familiarizado con C, esto es similar a la ... sintaxis utilizada en la función printf :
int printf(const char * format, ...);
pero de forma segura: cada argumento debe cumplir con el tipo especificado (en su muestra, deben ser todos String ).
Esta es una muestra simple de cómo puedes usar 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.
Podría decirse que es un ejemplo de azúcar sintáctico, ya que se implementa como una matriz de todos modos (lo que no significa que sea inútil). Prefiero pasar una matriz para mantenerla clara y también declarar métodos con matrices de un tipo dado. Sin embargo, más bien una opinión que una respuesta.
Significa que se pueden pasar cero o más objetos de cadena (o una matriz de ellos) como los argumentos 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ú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.
Solo piense en ello como la palabra clave params en C #, si viene de ese fondo :)
También para arrojar algo de luz, es importante saber que los parámetros var-arg están limitados a uno y no puede tener varios parámetros var-art. Por ejemplo, esto es iligal:
public void myMethod(String... strings, int ... ints){
// method body
}
Una forma muy común de ver un ejemplo claro del uso de los tres puntos está presente en uno de los métodos más famosos en AsyncTask Android (que hoy en día no se usa demasiado debido a RXJAVA, por no mencionar los componentes de la Arquitectura de Google), puede encontrar miles de ejemplos buscando este término, y la mejor manera de entender y nunca más olvidar el significado de los tres puntos es que expresan una ... duda ... como en el lenguaje común. Es decir, no está claro el número de parámetros que se deben pasar, podría ser 0, podría ser 1 podría ser más (una matriz) ...
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);
}
}
}
Es Varargs :)
El varargs corto para argumentos de longitud variable es una característica que permite al método aceptar un número variable de argumentos (cero o más). Con varargs se ha vuelto simple crear métodos que necesitan tomar un número variable de argumentos. La característica del argumento variable se ha agregado en Java 5.
Sintaxis de varargs
Un vararg se secifica mediante 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 fuera necesario un número variable de argumentos, había dos formas de manejarlo
Si el número máximo de argumentos, un método que se puede tomar es pequeño y conocido, se podrían crear versiones sobrecargadas del método. Si el número máximo de argumentos que podría tomar un método era grande y / o desconocido, el enfoque consistía en poner esos argumentos en una matriz y pasarlos a un método que tome la matriz como parámetro. Estos 2 enfoques eran propensos a errores: construir una serie de parámetros cada vez y 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 varargs
Ofrece una opción mucho más simple. Menos código ya que no hay necesidad de 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 varargs se pasan implícitamente como una matriz. Los argumentos que se pasan como varargs se almacenan en una matriz que se conoce por el nombre dado a varargs. En este programa el nombre de la matriz es valores. También tenga en cuenta que el método se llama con un número diferente de argumentos, primero llame 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 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 solo debe haber un parámetro varargs.
void displayValues(int a, int b, int … values, int … moreValues) // Compiler error
Sobrecarga de métodos varargs
Es posible sobrecargar un método que toma el parámetro varargs. El método de Varargs puede ser sobrecargado por -
Los tipos de su parámetro vararg pueden ser diferentes. Añadiendo otros parámetros. Ejemplo de sobrecarga del método 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 sobrecarga ambigua.
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 realizamos una llamada al método displayData () sin ningún parámetro, se produce un error, porque el compilador no está seguro de si esta llamada del método es para displayData(String ... values) o displayData(int ... values)
De la misma manera, si tenemos métodos sobrecargados donde uno tiene el método vararg de un tipo y otro método tiene un parámetro y un parámetro vararg 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.