The three dots can only be used in a method argument, and are called &#39;varargs&#39;. It means you can pass in an array of parameters without explicitly creating the array.

`private void method(String[] args) {}` is called like `method(new String[]{&quot;first&quot;, &quot;second&quot;});`

`private void method(String... args) {}` is called like `method(&quot;first&quot;, &quot;second&quot;);`

- An [array][1] is a fixed length collection of objects. e.g. `new int[5];`
- An [`ArrayList`][2] is a variable length collection of objects. e.g. `new ArrayList&lt;Integer&gt;();`
- The `...` in [variadic functions][3] is a part of a method signature denoting an array of parameters. e.g. `public void printLines(String... lines)`


  [1]: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html
  [2]: http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html
  [3]: http://en.wikipedia.org/wiki/Variadic_function

In other words, method(String...) means passing a variable number of parameters to the method.

I&#39;m writing some reconnect logic to periodically attempt to establish a connection to a remote endpoint which went down. Essentially, the code looks like this:

    public void establishConnection() {
        try {
            this.connection = newConnection();
        } catch (IOException e) {
            // connection failed, try again.
            try { Thread.sleep(1000); } catch (InterruptedException e) {};
            
            establishConnection();
        }
    }

I&#39;ve solved this general problem with code similar to the above on many occasions, but I feel largely unsatisfied with the result. Is there a design pattern designed for dealing with this issue?



Design pattern for &quot;retrying&quot; logic that failed?

**Math**:

If you have an equation like this:

    x = 3 mod 7

x could be ... -4, 3, 10, 17, ..., or more generally:

    x = 3 + k * 7

where k can be any integer. I don&#39;t know of a modulo operation is defined for math, but the  factor ring certainly is.

**Python**:

In Python, you will always get non-negative values when you use `%` with a positive `m`:

    #!/usr/bin/python
    # -*- coding: utf-8 -*-

    m = 7

    for i in xrange(-8, 10 + 1):
        print(i % 7)

Results in:

    6    0    1    2    3    4    5    6    0    1    2    3    4    5    6    0    1    2    3

**C++:**

    #include &lt;iostream&gt;

    using namespace std;

    int main(){
        int m = 7;

        for(int i=-8; i &lt;= 10; i++) {
            cout &lt;&lt; (i % m) &lt;&lt; endl;
        }

        return 0;
    }

Will output:

    -1    0    -6    -5    -4    -3    -2    -1    0    1    2    3    4    5    6    0    1    2    3    

**ISO/IEC 14882:2003(E) - 5.6 Multiplicative operators:**
&gt; The binary / operator yields the quotient, and the binary % operator
&gt; yields the remainder from the division of the first expression by the
&gt; second. If the second operand of / or % is zero the behavior is
&gt; undefined; otherwise (a/b)*b + a%b is equal to a. If both operands are
&gt; nonnegative then the remainder is nonnegative; if not, **the sign of the
&gt; remainder is implementation-defined 74)**.

and

&gt; 74) According to work underway toward the revision of ISO C, the
&gt; preferred algorithm for integer division follows the rules defined in
&gt; the ISO Fortran standard, ISO/IEC 1539:1991, in which the quotient is
&gt; always rounded toward zero.

Source: [ISO/IEC 14882:2003(E)][1] 

(I couldn&#39;t find a free version of `ISO/IEC 1539:1991`. Does anybody know where to get it from?)

The operation seems to be defined like this:

![enter image description here][2]

**Question**: 

Does it make sense to define it like that? 

What are arguments for this specification? Is there a place where the people who create such standards discuss about it? Where I can read something about the reasons why they decided to make it this way?

Most of the time when I use modulo, I want to access elements of a datastructure. In this case, I have to make sure that mod returns a non-negative value. So, for this case, it would be good of mod always returned a non-negative value. 
(Another usage is the [Euclidean algorithm][3]. As you could make both numbers positive before using this algorithm, the sign of modulo would matter.)

**Additional material**: 

See [Wikipedia][4] for a long list of what modulo does in different languages.


  [1]: http://cs.nyu.edu/courses/summer12/CSCI-GA.2110-001/downloads/C++%20Standard%202003.pdf
  [2]: http://i.stack.imgur.com/8p2MN.png
  [3]: http://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
  [4]: http://en.wikipedia.org/wiki/Modulo_operation#Remainder_calculation_for_the_modulo_operation

Why does C++ output negative numbers when using modulo?

I cannot figure out that what are the differences between `...` in java and arrays also array list, especially array list.

Both we can use as unlimited but `...` is rarely used.

Please help thanks in advance.

Difference between Arrays and 3 dots (Varargs) in java

I cannot figure out that what are the differences between <code>...</code> in java and arrays also array list, especially array list.
Both we can use as unlimited but <code>...</code> is rarely used.
Please help thanks in advance.

When creating a 2D array, how does one remember whether rows or columns are specified first?


Which comes first in a 2D array, rows or columns?

For example:

    try
    {
        SomeObject someObject = new SomeObject();
        someObject.dangerousMethod();
    }
    catch(Exception e)
    {
    }
    someObject.anotherMethod(); //can&#39;t access someObject!


But you can declare it before the `try/catch` block and then it works fine:

    SomeObject someObject;
    try
    {
        someObject = new SomeObject();
        someObject.dangerousMethod();
    }
    catch(Exception e)
    {
    }
    someObject.anotherMethod(); //works fine

I&#39;m just wondering the design reason for this.  Why are Objects created within the `try/catch` block not in scope with the rest of the method?  Maybe I&#39;m not understanding deep down how a `try/catch` works besides just watching for `Exceptions` thrown.

Why does a Try/Catch block create new variable scope?

I am using JPA 2. For safety reasons, I am working type safe with CriteriaQuery&#39;s (and thus, I am not searching for any solutions to typed queries and so on).

I recently came across an issue in which I needed to set a SQL-LIMIT.

After a lot of searching, I was still not successful in finding a solution.

    CriteriaQuery&lt;Product&gt; query = getEntityManager().getCriteriaBuilder().createQuery(Product.class);
    Root&lt;Product&gt; product = query.from(Product.class);
    query.select(product);

    return em.createQuery(query).getResultList();

Can anyone help me?

JPA 2 CriteriaQuery, using a limit

I have an array I&#39;d like to turn into a `List`, in order to modify the contents of the array.

Stack Overflow has plenty of questions/answers that address `Arrays.asList()` and how it only provides a List view of the underlying array, and how attempting to manipulate the resulting List will generally throw an `UnsupportedOperationException` as methods used to manipulate the list (e.g. `add()`, `remove()`, etc.) are not implemented by the List implementation provided by `Arrays.asList()`.

But I can&#39;t find an example of how to turn an array into a mutable List.  I suppose I can loop through the array and `put()` each value into a new List, but I&#39;m wondering if there&#39;s an interface that exists to do this for me.

Create mutable List from array?

I have a json string, which I should deSerialize to the following class

    class Data &lt;T&gt; {
        int found;
        Class&lt;T&gt; hits
    }

How do I do it?
This is the usual way

    mapper.readValue(jsonString, Data.class);
But how do I mention what T stands for?


Content Type	Original Author	Original Content on Stackoverflow
Question	user1550048	View Question on Stackoverflow
Solution 1 - Java	Jorn	View Answer on Stackoverflow
Solution 2 - Java	tskuzzy	View Answer on Stackoverflow
Solution 3 - Java	Aliaksandr Dvoineu	View Answer on Stackoverflow

Difference between Arrays and 3 dots (Varargs) in java

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

Why does C++ output negative numbers when using modulo?

Design pattern for "retrying" logic that failed?

Attributions