Argumentos variables (Varargs) en Java

Argumentos variables (Varargs) en Java es un método que toma un número variable de argumentos. Argumentos variables en Java simplifica la creación de métodos que necesitan tomar una cantidad variable de argumentos.

Necesidad de Java Varargs

• Hasta JDK 4, no podemos declarar un método con variable no. de argumentos Si hay algún cambio en el número de argumentos, tenemos que declarar un nuevo método. Este enfoque aumenta la longitud del código y reduce la legibilidad.
• Antes de JDK 5, los argumentos de longitud variable se podían manejar de dos formas. Uno usa un método sobrecargado (uno para cada uno) y otro coloca los argumentos en una array y luego pasa esta array al método. Ambos son potencialmente propensos a errores y requieren más código. 
• Para resolver estos problemas, se introdujeron Argumentos Variables (Varargs) en JDK 5. Desde JDK 5 en adelante, podemos declarar un método con un número variable de argumentos. Este tipo de métodos se denominan métodos de Varargs. La característica varargs ofrece una opción mejor y más simple.

Sintaxis de Varargs

Internamente, el método Varargs se implementa mediante el uso del concepto de arrays de dimensiones únicas. Por lo tanto, en el método de Varargs, podemos diferenciar argumentos usando Index. Un argumento de longitud variable se especifica mediante tres puntos o puntos (…). 

Por ejemplo, 

public static void fun(int ... a) 
{
   // method body
} 

Esta sintaxis le dice al compilador que se puede llamar a fun() con cero o más argumentos. Como resultado, aquí, a se declara implícitamente como una array de tipo int[].

A continuación se muestra un fragmento de código para ilustrar el concepto anterior:

// Java program to demonstrate varargs
 
class Test1 {
    // A method that takes variable
    // number of integer arguments.
    static void fun(int... a)
    {
        System.out.println("Number of arguments: "
                           + a.length);
 
        // using for each loop to display contents of a
        for (int i : a)
            System.out.print(i + " ");
        System.out.println();
    }
 
    // Driver code
    public static void main(String args[])
    {
        // Calling the varargs method with
        // different number of parameters
       
        // one parameter
        fun(100);
           
          // four parameters
        fun(1, 2, 3, 4);
         
          // no parameter
          fun();
    }
}

Number of arguments: 1
100 
Number of arguments: 4
1 2 3 4 
Number of arguments: 0

Explicación del programa anterior.

• La sintaxis … le dice al compilador que se han usado varargs, y estos argumentos deben almacenarse en la array a la que hace referencia un .
• La variable a se opera como una array. En este caso, hemos definido el tipo de datos de una array ‘a’ como int. Por lo tanto, solo puede tomar valores enteros. El número de argumentos se puede encontrar usando a.length, de la misma manera que encontramos la longitud de una array en Java.

Nota: un método puede tener parámetros de longitud variable con otros parámetros también, pero uno debe asegurarse de que solo exista un parámetro varargs que debe escribirse en último lugar en la lista de parámetros de la declaración del método. Por ejemplo:

int nums(int a, float b, double … c)

En este caso, los dos primeros argumentos coinciden con los dos primeros parámetros y los argumentos restantes pertenecen a c.

// Java program to demonstrate
//  varargs with normal arguments
 
class Test2 {
   
    // Takes string as a argument followed by varargs
    static void fun2(String str, int... a)
    {
        System.out.println("String: " + str);
        System.out.println("Number of arguments is: "
                           + a.length);
 
        // using for each loop to display contents of a
        for (int i : a)
            System.out.print(i + " ");
 
        System.out.println();
    }
 
    public static void main(String args[])
    {
        // Calling fun2() with different parameter
        fun2("GeeksforGeeks", 100, 200);
        fun2("CSPortal", 1, 2, 3, 4, 5);
        fun2("forGeeks");
    }
}

String: GeeksforGeeks
Number of arguments is: 2
100 200 
String: CSPortal
Number of arguments is: 5
1 2 3 4 5 
String: forGeeks
Number of arguments is: 0

Ejemplos de Varargs erróneos

Caso 1: Especificación de dos Varargs en un solo método: 

void method(String... gfg, int... q)
{
    // Compile time error as there 
    // are two varargs
}

Caso 2: Especificar Varargs como el primer parámetro del método en lugar del último: 

void method(int... gfg, String q)
{
    // Compile time error as vararg 
    // appear before normal argument
}

Puntos importantes sobre Varargs

• Los métodos Vararg también se pueden sobrecargar, pero la sobrecarga puede generar ambigüedad.
• Antes de JDK 5, los argumentos de longitud variable se podían manejar de dos maneras: una usaba la sobrecarga, la otra usaba un argumento de array.
• Solo puede haber un argumento variable en un método.
• El argumento variable (Varargs) debe ser el último argumento.

Este artículo es una contribución de Niraj Srimal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo en write.geeksforgeeks.org . Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.