Varargs de Java

Hoy discutiremos algo como varargs en Java. Varargs, o argumentos variables, es una tecnología que le permite crear métodos con una cantidad arbitraria de argumentos. En este artículo aprenderemos cómo crear dichos métodos, discutiremos por qué se necesitan varargs y cuándo es mejor usarlos.

¿Qué son los varargs?

Los varargs son argumentos de longitud variable: una característica que apareció en JDK5. Varargs nos permite crear métodos con una cantidad arbitraria de argumentos. En general, estos métodos ya eran posibles antes. Es cierto que no fue muy conveniente hacer esto. Pongamos un ejemplo. Digamos que necesitamos escribir un método que tome un número arbitrario de argumentos enteros y los sume. Tenemos dos opciones. Opción 1 - sobrecarga:

class Calculator {
    int sum(int a, int b){...};
    int sum(int a, int b, int c){...};
    int sum(int a, int b, int c, int d){...};
    int sum(int a, int b, int c, int d, int e){...};
}

Pero hay dos problemas con la sobrecarga. En primer lugar, no siempre está claro cuándo es el momento de parar y, en segundo lugar, es engorroso. Las matrices son mejores. Opción 2 - matrices:

class Calculator {
    int sum(int[] numbers){...};
}

Con un array ya no es engorroso, y el array parece no tener nada... hasta que llega el momento de llamar al método:

public static void main(String... sss) {
    Calculator calculator = new Calculator();

    int[] arguments = new int[7];
    arguments[0] = 1;
    arguments[1] = 10;
    arguments[2] = 123;
    arguments[3] = 234;
    arguments[4] = 6234;
    arguments[5] = 12;
    arguments[6] = 8;

    int sum = calculator.sum(arguments);
}

Estamos de acuerdo, por supuesto puedes escribir todo más brevemente. Pero en primer lugar, todavía me gustaría demostrar los inconvenientes de usar matrices como argumentos de longitud variable y, en segundo lugar, incluso si lo escribimos así:

int[] arguments = {1,10,123,234,6234,12,8};
int sum = calculator.sum(arguments);

Entonces todavía no nos desharemos de la cantidad excesiva de código. Sin embargo, con el lanzamiento de Java 5, la función Varargs pareció resolver estos problemas. Hizo posible pasar una cantidad arbitraria de argumentos a los métodos. Se parece a esto:

public class Calculator {
    public static void main(String... sss) {
        Calculator calculator = new Calculator();
        int sum = calculator.sum(1,10,123,234,6234,12,8);
    }
    int sum(int... numbers){
       return Arrays.stream(numbers).sum();
    }
}

Entonces, resumamos. Los Varargs son argumentos de longitud variable, una característica que apareció con el lanzamiento de Java 5. A continuación, veremos más de cerca algunas reglas para trabajar con Varargs.

5 reglas de varargs

Regla 1. El argumento Vararg (o argumento de longitud variable/arbitraria) se indica mediante puntos suspensivos de la siguiente manera:

String... words
Integer... numbers
Person... people
Cat... cats

Regla 2. Un argumento de longitud arbitraria sólo puede especificarse como argumento de algún método:

void print(String... words)
int sum(Integer... numbers)
void save(Person... people)
void feed(Cat... cats)

Regla 3. Cada uno de estos argumentos de longitud variable en el cuerpo del método es una matriz:

void print(String... words){
    for (int i = 0; i < words.length; i++) {
        System.out.println(words[i]);
    }
}

Regla 4. El argumento Vararg debe ser el último en la lista de argumentos del método:

void print(String... words, String anotherWord) // - Так нельзя!
void print(String... words, int someNumber) // - Так нельзя!

void print(String anotherWord, String... words) // - Так можно
void print(int someNumber, String... words) // - Так можно

Regla 5: aunque los varargs son matrices, cuando se llama a un método que toma argumentos de longitud variable, no es necesario crear una matriz. Es suficiente e incluso deseable enumerar simplemente los argumentos necesarios separados por comas:

public class Main {
    public static void main(String... sss) {
        print("Cómo","же","прекрасно","изучать","Java");
    }

    static void print(String... words){
        for (int i = 0; i < words.length; i++) {
            System.out.println(words[i]);
        }
    }
}

Ejemplos de varargs

En el siguiente ejemplo, escribiremos un método que toma varargs que constan de números enteros y muestra la cantidad de elementos pasados ​​y su suma. Pasemos tanto una matriz como una serie de números enteros a este método (ambas opciones son válidas):

public static void main(String... sss) {
    int[] a = new int[100];
    for (int i = 0; i < a.length; i++) {
        a[i] = i;
    }

    sum(a);
    sum(1,2,3,4,5,6,7,8,9,10);
}

static void sum(int... numbers){
    final int length = numbers.length;
    final int sum = Arrays.stream(numbers).sum();
    final String lineSeparator = System.lineSeparator();

    System.out.printf("Кол-во элементов для сложения - %d, сумма - %d%s", length, sum, lineSeparator);
}

Después de ejecutar el programa generará:

Кол-во элементов для сложения - 100, сумма - 4950 
Кол-во элементов для сложения - 10, сумма - 55 

Vale la pena mencionar que el método System.out.printftambién acepta varargs. Si miramos el código de este método, veremos esto:

public PrintStream printf(String format, Object ... args) {
    return format(format, args);
}

Otro método ampliamente utilizado que acepta varags es String.format. Su código se muestra a continuación:

public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

¿Cuándo usar varargs?

La respuesta a esta pregunta depende de quién la pregunte. Si un cliente de alguna API que tiene métodos con varargs hace una pregunta similar, entonces la respuesta sería "use dichos métodos con la mayor frecuencia posible". Para el cliente de código, varargs hace la vida mucho más fácil al hacer que el código sea más fácil de escribir y legible. Sin embargo, si un desarrollador de API hace esta pregunta y se pregunta con qué frecuencia debe crear métodos con varargs, entonces la respuesta será "no debe usar varargs con frecuencia". Varargs sólo debe utilizarse cuando el beneficio de su uso sea evidente. También debe evitar sobrecargar métodos con varargs, ya que esto dificultará que los clientes de su código comprendan cuál de los métodos sobrecargados se llama realmente.

Conclusión

Entonces, hemos cubierto otro tema, varargs en Java. Descubrimos qué es. Describimos las reglas para usar varargs. Analizamos ejemplos de métodos con argumentos de longitud arbitraria y también discutimos cuándo es mejor usar varargs y cuándo es mejor abstenerse de usarlos. Como tarea, puedes implementar los siguientes métodos:

• Escribe voidun método que tome una serie de números enteros y devuelva su media aritmética.
• Escribe voidun método que tome una serie de cadenas e imprima la palabra más larga.
• Escriba un método que devuelva booleany tome una variable de tipo como primer argumento Stringy una serie booleande longitud variable como siguiente argumento.
  Los valores posibles Stringson AND, OR, XOR. Si el primer argumento tiene algún otro valor, el método debe generar una excepción IllegalArgumentException.
  El método debe realizar una operación lógica (especificada en el primer argumento) en cada elemento del argumento varargs y devolver el resultado del cálculo.

Argumentos de ejemplo y resultado:

• "Y", verdadero, verdadero, falso - devolverá falso
• "O", falso, verdadero, falso, falso - devolverá verdadero