What Is the Ellipsis (...) For in This Method Signature

What is the ellipsis (...) for in this method signature?

Those are Java varargs. They let you pass any number of objects of a specific type (in this case they are of type JID).

In your example, the following function calls would be valid:

MessageBuilder msgBuilder; //There should probably be a call to a constructor here ;)
MessageBuilder msgBuilder2;
msgBuilder.withRecipientJids(jid1, jid2);
msgBuilder2.withRecipientJids(jid1, jid2, jid78_a, someOtherJid);

See more here:
http://java.sun.com/j2se/1.5.0/docs/guide/language/varargs.html

Use of ellipsis(...) in Java?

It means that this method can receive more than one Object as a parameter. To better understating check the following example from here:

The ellipsis (...) identifies a variable number of arguments, and is
demonstrated in the following summation method.

static int sum (int ... numbers)
{
   int total = 0;
   for (int i = 0; i < numbers.length; i++)
        total += numbers [i];
   return total;
}

Call the summation method with as many comma-delimited integer
arguments as you desire -- within the JVM's limits. Some examples: sum
(10, 20) and sum (18, 20, 305, 4).

This is very useful since it permits your method to became more abstract. Check also this nice example from SO, were the user takes advantage of the ... notation to make a method to concatenate string arrays in Java.

Another example from Variable argument method in Java 5

public static void test(int some, String... args) {
        System.out.print("\n" + some);
        for(String arg: args) {
            System.out.print(", " + arg);
        }
    }

As mention in the comment section:

Also note that if the function passes other parameters of different
types than varargs parameter, the vararg parameter should be the last
parameter in the function declaration public void test (Typev ... v ,
Type1 a, Type2 b) or public void test(Type1 a, Typev ... v
recipientJids, Type2 b) - is illegal. ONLY public void test(Type1 a,
Type2 b, Typev ... v)

What are these three dots in parameter types

One word: varargs.

The three periods after the final parameter's type indicate that the final argument may be passed as an array or as a sequence of arguments. Varargs can be used only in the final argument position.

Ellipsis behavior (...) in method signature with an Iterable?

I tested it in Ideone (using Java6):

import java.util.*;
import java.lang.*; 

class Main{

    public static void main (String[] args) throws java.lang.Exception{
        testIterable(getStringList());     
    }

    public static ArrayList<String> getStringList(){
        ArrayList<String> stringList = new ArrayList<String>();

        stringList.add("String one");
        stringList.add("String two");

        return stringList;       

    }

    public static void testIterable(Object...objects){
        for(Object object : objects){
            System.out.println("Object: "+ object.toString());
        }
    }
}

The expected output would be:

Object: String one

Object: String two

Unfortunately, the output was as follows:

Object: [String one, String two]

So it took the whole ArrayList as one Object.

EDIT:

However, converting the ArrayList to a String[] produces the desired behavior, and is a simple task:

public static String[] convertToArray(ArrayList<String> stringList){
    String[] stringArray = new String[stringList.size()];
    // If we use toArray() without an argument, it will return Object[]
    return stringList.toArray(stringArray);
}

Ideone link

What is the ellipsis beside a data type parameter means?

The ellipsis is the three dot (...) notation is actually borrowed from mathematics, and it means "...and so on".

As for its use in Java, it stands for varargs, meaning that any number of arguments can be added to the method call. The only limitations are that the varargs must be at the end of the method signature and there can only be one per method.

In Java is using the ellipsis to represent an optional parameter a good idea?

The proper term for the ellipsis is varargs. Varargs allow a developer to pass a variable number of arguments.

It is not an good idea to use varargs to provide one optional argument. It is better to use overloading as in the code example below.

public void update(Object object)
{
    update(update, false);
}

public void update(Object object, boolean check)
{
    if (check)
    {
        ...
    } //if
}

This way a developer is unable to pass in multiple booleans but is allowed to pass in none.

What is the meaning of three dots (...) in PHP?

This is literally called the ... operator in PHP, but is known as the splat operator from other languages. From a 2014 LornaJane blog post on the feature:

This feature allows you to capture a variable number of arguments to a function, combined with "normal" arguments passed in if you like. It's easiest to see with an example:

function concatenate($transform, ...$strings) {
  $string = '';
  foreach($strings as $piece) {
      $string .= $piece;
  }
  return($transform($string));    }

echo concatenate("strtoupper", "I'd ", "like ", 4 + 2, " apples");

(This would print I'D LIKE 6 APPLES)

The parameters list in the function declaration has the ... operator in it, and it basically means " ... and everything else should go into $strings". You can pass 2 or more arguments into this function and the second and subsequent ones will be added to the $strings array, ready to be used.

What do the 3 dots in Java generics mean?

The three dots are referred to as varargs and here, allow you to pass more than one string to the method like so:

doInBackground("hello","world");
//you can also do this:
doInBackground(new String[]{"hello","world"});

Documentation on that here.

Within the method doInBackground you can enumerate over the varargs variable, params like so:

for(int i=0;i<params.length;i++){
    System.out.println(params[i]);
}

So its basically an array of strings within the scope of doInBackground

What is the ... operator used while receiving arrays in java method arguments

... is the elipsis (varargs) operator. In short, it's a syntactic sugar that allows you to pass a variable number of arguments to the method using commas (,). Inside the method, the argument is treated as an array.

So int[]... z means that z is treated as an array of int[], or int[][].

Significance of Object...

It is called as variable arguments or simply var-args, Introduced in java 5. If you method accepts an var-args as a parameter, you can pass any number of parameters to that method. for instance below method calls would all succeed for your method declaration:

 doInBackground(new Object());
 doInBackground(new Object(), new Object());
 doInBackground(new Object(), new Object(), new Object());
 doInBackground(new Object(), new Object(), new Object(), new Object());

A previous post should give you more information
Can I pass an array as arguments to a method with variable arguments in Java?

---

Related Topics