What do 3 dots next to a parameter type mean in Java?

Что означают следующие 3 точки String в следующем методе?

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

Это означает, что ноль или более строковых объектов (или один их массив) могут быть переданы в качестве аргумента (ов) для этого метода.

Смотрите раздел "Произвольное количество аргументов" здесь: http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs

В вашем примере вы могли бы назвать это любым из следующих способов:

myMethod(); // Likely useless, but possible
myMethod("one", "two", "three");
myMethod("solo");
myMethod(new String[]{"a", "b", "c"});

Важное примечание: Аргумент (ы), передаваемый таким образом, всегда является массивом, даже если он всего один. Убедитесь, что вы обрабатываете его таким образом в теле метода.

Важное примечание 2: Аргумент, который получает ..., должен быть последним в сигнатуре метода. Итак, myMethod(int i, String... strings) это нормально, но myMethod(String... strings, int i) это не нормально.

Спасибо Вашему за разъяснения в его комментарии.

Эта функция называется varargs, и это функция, представленная в Java 5. Это означает, что функция может получать несколько String аргументов:

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

Затем вы можете использовать String var в качестве массива:

public void myMethod(String... strings) {
    for (String whatever : strings) {
        // do what ever you want
    }

    // the code above is equivalent to
    for (int i = 0; i < strings.length; i++) {
        // classical for. In this case you use strings[i]
    }
}

Этот ответ сильно заимствован у кисвы и Лоренцо... а также из комментария Graphain .

Это Varargs :)

Сокращение varargs от аргументов переменной длины - это функция, которая позволяет методу принимать переменное количество аргументов (ноль или более). С помощью varargs стало проще создавать методы, которые должны принимать переменное количество аргументов. В Java 5 добавлена функция variable argument.

Синтаксис varargs

vararg обозначается тремя многоточиями (тремя точками) после типа данных, его общая форма такова

return_type method_name(data_type ... variableName){
}  

Необходимость в varargs

До Java 5 на случай, если возникала необходимость в переменном количестве аргументов, существовало два способа справиться с этим

Если максимальное количество аргументов, которое может принимать метод, было небольшим и известным, то могли быть созданы перегруженные версии метода. Если максимальное количество аргументов, которое может принять метод, было большим или / и неизвестным, то подход заключался в том, чтобы поместить эти аргументы в массив и передать их методу, который принимает array в качестве параметра. Эти два подхода были подвержены ошибкам - каждый раз создавался массив параметров, и их было сложно поддерживать, - поскольку добавление нового аргумента может привести к написанию нового перегруженного метода.

Преимущества varargs

Предлагает гораздо более простой вариант. Меньше кода, так как нет необходимости писать перегруженные методы.

Пример 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

Из программы видно, что length используется здесь для определения количества аргументов, передаваемых методу. Это возможно, потому что переменные значения неявно передаются в виде массива. Любые аргументы, передаваемые как переменные, хранятся в массиве, на который ссылается имя, данное varargs. В этой программе имя массива - values .
Также обратите внимание, что метод вызывается с разным количеством аргументов, сначала вызывается с четырьмя аргументами, затем с тремя аргументами, а затем с нулевыми аргументами. Все эти вызовы обрабатываются одним и тем же методом, который принимает varargs .

Ограничение с помощью varargs

В методе могут быть другие параметры с параметром varargs, однако в этом случае параметр varargs должен быть последним параметром, объявленным методом.

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

Еще одно ограничение, связанное с varargs, заключается в том, что должен быть только один параметр varargs.

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

Перегрузка методов varargs

Возможно перегрузить метод, который принимает параметр varargs. Метод Varargs может быть перегружен с помощью -

Типы его параметра vararg могут отличаться. Путем добавления других параметров. Пример перегрузки метода varargs

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. Давайте посмотрим пример

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

В этой программе, когда мы вызываем метод displayData() без какого-либо параметра, он выдает ошибку, потому что компилятор не уверен, предназначен ли этот вызов метода для displayData(String ... values) или displayData(int ... values)

Точно так же, если у нас есть перегруженные методы, в которых у одного есть vararg метод одного типа, а у другого метода есть один параметр и vararg параметр того же типа, тогда мы также имеем двусмысленность - Как Exp - displayData(int ... values) и displayData(int a, int ... values)

Эти два перегруженных метода всегда будут иметь неоднозначность.

Это способ Java передавать varargs (аргументы с переменным числом).

Если вы знакомы с C, это похоже на ... синтаксис, используемый в printf функции:

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

но типобезопасным способом: каждый аргумент должен соответствовать указанному типу (в вашем примере они должны быть все String).

Это простой пример того, как вы можете использовать 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");
   }
}

... Аргумент на самом деле является массивом, поэтому вы могли бы передать String[] в качестве параметра.