Parâmetros variáveis (Varargs) no Java

Neste artigo, você aprenderá sobre os parâmetros variáveis (Varargs) no Java com a ajuda de exemplos. Você também aprenderá quando usar varargs e quando não usá-los.

O que são varargs no Java?

Supondo que você esteja criandoMétodos Java. Mas você não tem certeza de quantos parâmetros seu método vai aceitar. Para resolver este problema, o Java 1.5Introdução de varargs.

Varargs é a abreviação de parâmetros variáveis. No Java, os parâmetros de um método podem aceitar qualquer quantidade de valores. O parâmetro que pode aceitar uma quantidade variável de valores é chamado de varargs.

A sintaxe para implementar varargs é a seguinte:

accessModifier methodName(datatype... arg) {
　　　　//　Corpo do método
}

Para definir vararg, use ... (três pontos) nos parâmetros do método.

Os métodos que aceitam uma quantidade variável de parâmetros são chamados de métodos de quantidade variável, ou simplesmente métodos varargs.

Primeiro, vamos ver um exemplo sem a utilização de varargs:

class NoVararg {
　　　　public int sumNumber(int a, int b){
　　　　　　　　return a+b;
　　　　}
　　　　public int sumNumber(int a, int b, int c){
　　　　　　　　return a+b;+c;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　NoVararg obj = new NoVararg();
　　　　　　　　System.out.println(obj.sumNumber(1,　2));
　　　　　　　　System.out.println(obj.sumNumber(1,　2,　3));
　　　　}
}

Quando você executar o programa, a saída será:

3
6

Como você vê, é necessário sobrecarregar o método sumNumber() para torná-lo adequado para3parâmetros.

se o usuário desejar adicionar5número ou10ou100, o que fazer?

A utilização de varargs permite lidar com este problema de maneira concisa. Vamos ver um exemplo de código:

Exemplo: Demonstração de trabalho com parâmetros variáveis

class VarargExample {
　　　　public int sumNumber(int ... args){
　　　　　　　　System.out.println("Comprimento do parâmetro: "　+　args.length);
　　　　　　　　int soma = 0;
　　　　　　　　for(int x: args){
　　　　　　　　　　　　soma　+=
　　　　　　　　}
　　　　　　　　return sum;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　VarargExample ex = new VarargExample();
　　　　　　　　int sum2　=2,　4);
　　　　　　　　System.out.println("sum2　=　+　soma2);
　　　　　　　　int sum3　=1,　3,　5);
　　　　　　　　System.out.println("sum3　=　+　soma3);
　　　　　　　　int sum4　=1,　3,　5,　7);
　　　　　　　　System.out.println("sum4　=　+　soma4);
　　　　}
}

Quando o programa é executado, a saída é:

Tamanho dos parâmetros:　2
soma2　=　6
Tamanho dos parâmetros:　3
soma3　=　9
Tamanho dos parâmetros:　4
soma4　=　16

Aqui, o método sumNumber() retorna a soma dos parâmetros int passados a ele (independente do número de parâmetros passados).

Como você vê, os varargs são muito úteis em alguns casos. Mas, se você estiver certo da quantidade de parâmetros a serem passados para o método, use a sobrecarga de método. Por exemplo, se você estiver certo de que o método sumNumber() é usado apenas para calcular2ou3A soma total dos parâmetros, use a sobrecarga como no primeiro exemplo.

Vamos dar outro exemplo. O método format() definido na biblioteca Java aceita varargs. No JDK, o método format() é definido assim:

public static String format(Locale l, String format, Object... args) {
　　　　//　corpo
}

Exemplo: método format()

class Company {
　　　　public static void main(String[] args) {
　　　　　　　　String siteName = "oldtoolbag.com";
　　　　　　　　int empCount =　6;
　　　　　　　　String type = "Site de tutorial";
　　　　　　　　System.out.println(
　　　　　　　　　　　　　　　　String.format(
　　　　　　　　　　　　　　　　　　　　　　　　"Nome do Site: %s, Contagem de Emp: %d Tipo: %s",
　　　　　　　　　　　　　　　　　　　　　　　　siteName, empCount, type
　　　　　　　　　　　　　　　　)
　　　　　　　　);
　　　　}
}

Quando o programa é executado, a saída é:

Nome do Site: oldtoolbag.com, Contagem de Emp:　6　Tipo: Site de tutorial

Como os parâmetros variáveis funcionam em segundo plano?

Vamos olhar para o seguinte código pseudocódigo:

public int sumNumber(int ...nums) {
　　　　//　Corpo do método
}

... A sintaxe informa ao compilador Java que pode usar zero ou mais parâmetros para chamar esse método. Como resultado, a variável nums é implicitamente declarada como int [].ArrayPortanto, dentro do método, use a sintaxe de array para acessar a variável nums.

Se não houver parâmetros, a comprimento nums é 0.

Sobrecarga de métodos Varargs

Como em métodos típicos, você pode sobrecarregar métodos vararg.

Exemplo: Sobrecarga de métodos Varargs

class VarargOverload {}}
　　　　private void test(int ... args){
　　　　　　　　int soma = 0;
　　　　　　　　for (int i: args) {
　　　　　　　　　　　　soma　+= i;
　　　　　　　　}
　　　　　　　　System.out.println("soma = ",　+　soma);
　　　　}
　　　　private void test(boolean p, String ... args){
　　　　　　　　boolean negar = !p;
　　　　　　　　System.out.println("negar = ",　+　negar);
　　　　　　　　System.out.println("args.length = ",+　args.length);
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　VarargOverload obj = new VarargOverload();
　　　　　　　　obj.test(1,　2,　3);
　　　　　　　　obj.test(true, "hello", "world");
　　　　}
}

Quando o programa é executado, a saída é:

soma =　6
negar = false
args.length =　2

No programa acima, o método test() é sobrecarregado ao alterar o número de parâmetros aceitos.

Coisas a lembrar ao usar Varargs

Essas são algumas coisas a lembrar ao usar Varargs em Java:

1Na definição da assinatura do método, certifique-se deManterPor fim, varargs.

Os parâmetros variáveis devem ser os últimos parâmetros passados ao método. Considere, por exemplo, que você chamou o método doSomething() assim:

fazerAlgo(1,　2,　3,　4);

E, a sua definição de método doSomething() é:

//Declaração de método incorreta
public void fazerAlgo(int ... nums, int p){
　　　　//　corpo do método
}

Neste caso, o compilador não pode determinar o número de parâmetros passados para nums.

Mas, se definirmos o método como:

public void fazerAlgo(int p, int ... nums) {
　　　　//　corpo do método
}

O compilador Java atribui o primeiro parâmetro a p e o resto dos parâmetros int a nums.

2Um método pode ter apenas um parâmetro varargs.

Por exemplo, a declaração deste método está incorreta:

int fazerAlgo(int p, float ... floatNums, double ... doubleNums) {
　　　　//　code
}

Ambiguidade na Sobrecarga de Métodos Varargs

Vamos ver um exemplo de sobrecarga de métodos test():

class Demo {　
　　
　　　　static void test(int ... vargs) {
　　　　　　　　//　corpo do método
　　　　}
　　　　
　　　　static void test(int n, int ... vargs) {
　　　　　　　　//　corpo do método
　　　　}
}

No programa acima, mesmo que você tente chamar o método test(), mesmo que o método test() esteja sobrecarregado e aceite diferentes números de parâmetros, o compilador ficará confuso.

O compilador não sabe qual método chamar. O compilador pode pensar que você está tentando chamar test(int ... vargs) usando um parâmetro varargs. Da mesma forma, o compilador pode pensar que você está tentando chamar test(int n, int ... vargs) usando os parâmetros passados para o primeiro parâmetro, enquanto o segundo parâmetro está vazio.

Devido às duas possíveis opções, pode haver ambiguidade. Portanto, às vezes você pode precisar usar dois nomes de métodos diferentes, em vez de sobrecarregar métodos varargs.