Java, 3 pontos nos parâmetros

Esse recurso é chamado varargs , e é um recurso introduzido no Java 5. Significa que a função pode receber múltiplos argumentos String:

myMethod("foo", "bar");
myMethod("foo", "bar", "baz");
myMethod(new String[]{"foo", "var", "baz"}); // you can even pass an array

Então, você pode usar o String var como um array:

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 é a forma Java de passar varargs (argumentos de números variáveis).

Se estiver familiarizado com C, isto é semelhante à sintaxe ... usada a função printf:

int printf(const char * format, ...);

Mas de uma forma segura do tipo: cada argumento tem que cumprir com o tipo especificado (na sua amostra, eles devem ser todos String).

Esta é uma amostra simples de como pode utilizar 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");
   }
}

O argumento ... é na verdade um array, então você pode passar por um String[] como parâmetro.

Sem dúvida, é um exemplo de açúcar sintático, uma vez que é implementado como um array de qualquer maneira (o que não significa que seja inútil) - eu prefiro passar um array para mantê-lo claro, e também declarar métodos com arrays de dado tipo. Mas é mais uma opinião do que uma resposta.

É o Varargs. :)

O varargs curto para argumentos de comprimento variável é uma característica que permite ao método aceitar o número variável de argumentos (zero ou mais). Com varargs tornou-se simples criar métodos que precisam tomar um número variável de argumentos. A característica do argumento variável foi adicionada em Java 5.

Sintaxe dos varargs

Uma vararg é seccionada por três elipses (três pontos) após o tipo de dados., a sua forma geral é

return_type method_name(data_type ... variableName){
}  

Necessidade de varargs

Antes do Java 5, no caso de haver necessidade de um número variável de argumentos, havia duas maneiras de lidar com isso

Se o número máximo de argumentos, um método pode tomar era pequeno e conhecido, então versões sobrecarregadas do método poderiam ser criadas. Se o número máximo de argumentos que um método poderia ter era grande ou / e desconhecido, então a abordagem era colocar esses argumentos em um array e passá-los a um método que toma array como um parâmetro. Estas duas abordagens eram propensas a erros-construindo uma série de Parâmetros cada vez e difícil de manter - como a adição de novos argumentos pode resultar na escrita de um novo método sobrecarregado.

Vantagens dos varargs

Oferece uma opção muito mais simples. Menos código como nenhuma necessidade de escrever métodos sobrecarregados.

Exemplo 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

Pode ser visto a partir do programa que o comprimento é usado aqui para encontrar o número de argumentos passados ao método. É possível porque varargs são implicitamente passados como uma matriz. Quaisquer argumentos são passados como varargs são armazenados em um array que é referido pelo nome dado a varargs. Neste programa o nome do array é values. Note também que o método é chamado com um número diferente de argumentos, primeiro chamada com quatro argumentos, depois três argumentos e, em seguida, com argumentos zero. Todas estas chamadas são tratadas pelo mesmo método que leva varargs.

Restrição com varargs

É possível ter outros parâmetros com o parâmetro varargs num método, no entanto, nesse caso, o parâmetro varargs deve ser o último parâmetro declarado pelo método.

void displayValues(int a, int b, int … values) // OK
   void displayValues(int a, int b, int … values, int c) // compiler error

Outra restrição com varargs é que deve haver apenas um parâmetro varargs.

void displayValues(int a, int b, int … values, int … moreValues) // Compiler error

Sobrecarregar os métodos de varargs

É possível sobrecarregar um método que toma o parâmetro varargs. Método Varargs pode ser sobrecarregado por -

Os Tipos do parâmetro vararg podem ser diferentes. Adicionando outros parâmetros. Exemplo do método varargs de sobrecarga

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 e sobrelotação ambigüidade

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

Neste programa, quando fazemos uma chamada para o método displayData() sem qualquer parâmetro ele lança erro, porque o compilador não tem certeza se este método a chamada é para displayData(String ... values) ou displayData(int ... values)

Mesma forma, se temos métodos sobrecarregados, onde tem-se a vararg método de um tipo e de outro método tem um parâmetro e vararg parâmetro do mesmo tipo, então também temos a ambiguidade - Val. - displayData(int ... values) e displayData(int a, int ... values)

public void myMethod(String... strings, int ... ints){
// method body
}

Basta pensar nisso como a palavra-chave {[[0]} em C#, Se você está vindo desse fundo:)

String... é o mesmo 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);

        }
        }
        }

Realmente Uma maneira comum para ver um exemplo claro do uso dos três pontos está presente em um dos mais famosos métodos de android AsyncTask ( que hoje não é muito usada devido RXJAVA, para não mencionar o Google componentes de Arquitetura), você pode encontrar milhares de exemplos de busca para este termo, e a melhor maneira de entender e nunca se esqueça do mais, o significado dos três pontos é que eles expressam um ...duvida... tal como na linguagem comum. Ou seja, é não limpar o número de parâmetros que têm que ser passados, poderia ser 0, poderia ser 1 poderia ser mais( um array)...