Varargs Java

Hoje discutiremos varargs em Java. Varargs – ou Argumentos Variáveis ​​– é uma tecnologia que permite criar métodos com um número arbitrário de argumentos. Neste artigo, aprenderemos como criar tais métodos, discutir por que os varargs são necessários e quando é melhor usá-los.

O que são varargs?

Varargs são argumentos de comprimento variável: um recurso que apareceu no JDK5. Varargs nos permite criar métodos com um número arbitrário de argumentos. Em geral, já foi possível criar tais métodos antes. É verdade que não foi muito conveniente fazer isso. Vamos dar um exemplo. Digamos que precisamos escrever um método que pegue um número arbitrário de argumentos inteiros e os some. Temos duas opções. Opção 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){...};
}

Mas existem dois problemas com a sobrecarga. Em primeiro lugar, nem sempre é claro quando é altura de parar e, em segundo lugar, é complicado. Matrizes são melhores. Opção 2 - matrizes:

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

Com um array não é mais complicado, e o array parece não se parecer com nada... até chegar a hora de chamar o 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);
}

Concordamos, você pode, é claro, escrever tudo de forma mais resumida. Mas, em primeiro lugar, ainda gostaria de demonstrar a inconveniência de usar arrays como argumentos de comprimento variável e, em segundo lugar, mesmo se escrevermos assim:

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

Então ainda não nos livraremos da quantidade excessiva de código. Porém, com o lançamento do Java 5, o recurso Varargs apareceu para resolver esses problemas. Tornou possível passar um número arbitrário de argumentos aos métodos. Parece algo assim:

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();
    }
}

Então, vamos resumir. Varargs são argumentos de comprimento variável, um recurso que apareceu com o lançamento do Java 5. A seguir, examinaremos mais de perto algumas regras para trabalhar com Varargs.

5 regras de varargs

Regra 1. O argumento Vararg (ou argumento de comprimento variável/arbitrário) é indicado por reticências como segue:

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

Regra 2. Um argumento de comprimento arbitrário só pode ser especificado como argumento para algum método:

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

Regra 3. Cada argumento de comprimento variável no corpo do método é um array:

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

Regra 4. O argumento Vararg deve ser o último na lista de argumentos do 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) // - Так можно

Regra 5: Embora varargs sejam arrays, ao chamar um método que aceita argumentos de comprimento variável, não é necessário criar um array. É suficiente e até desejável simplesmente listar os argumentos necessários separados por vírgulas:

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

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

Exemplos de varargs

No exemplo abaixo, escreveremos um método que pega varargs consistindo de inteiros e exibe o número de elementos passados ​​e sua soma. Vamos passar um array e uma série de inteiros para este método (ambas as opções são 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);
}

Após a execução o programa irá gerar:

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

Vale ressaltar que o método System.out.printftambém aceita varargs. Se olharmos o código deste método, veremos o seguinte:

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

Outro método amplamente utilizado que aceita varags é o String.format. Seu código é mostrado abaixo:

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

Quando usar varargs?

A resposta a esta pergunta depende de quem está perguntando. Se uma pergunta semelhante for feita por um cliente de alguma API que possui métodos com varargs, a resposta seria “use esses métodos com a maior freqüência possível”. Para o cliente de código, varargs torna a vida muito mais fácil, tornando o código mais fácil de escrever e mais legível. No entanto, se esta pergunta for feita por um desenvolvedor de API que está se perguntando com que frequência você deve criar métodos com varargs, então a resposta será “você não deve usar varargs com frequência”. Varargs só deve ser usado quando o benefício de seu uso for óbvio. Você também deve evitar sobrecarregar métodos com varargs, pois isso tornará difícil para os clientes do seu código entenderem qual dos métodos sobrecarregados é realmente chamado.

Conclusão

Então, cobrimos outro tópico, varargs em Java. Nós descobrimos o que é. Descrevemos as regras para usar varargs. Vimos exemplos de métodos com argumentos de comprimento arbitrário e também discutimos quando é melhor usar varargs e quando é melhor evitar usá-los. Como lição de casa, você pode implementar os seguintes métodos:

• Escreva voidum método que receba uma série de números inteiros e retorne sua média aritmética.
• Escreva voidum método que pegue uma série de strings e imprima a palavra mais longa.
• Escreva um método que retorne booleane receba uma variável de tipo como primeiro argumento Stringe uma série booleande comprimento variável como próximo argumento.
  Os valores possíveis Stringsão AND, OR, XOR. Se o primeiro argumento tiver algum outro valor, o método deverá lançar uma exceção IllegalArgumentException.
  O método deve realizar uma operação lógica (especificada no primeiro argumento) em cada elemento do argumento varargs e retornar o resultado do cálculo.

Argumentos de exemplo e resultado:

• "AND", verdadeiro, verdadeiro, falso - retornará falso
• "OU", falso, verdadeiro, falso, falso - retornará verdadeiro