Java spread operator

Question

I am not sure of the vocabulary I am using here, please correct me if I\'m wrong.

In Javascript, I had the following code:

let args = [1,2,3];

func         


        

Answer 1

In java there is concept of Variable Arguments, using which you can pass different numbers of arguments to same function.

I am taking your code as an example :

public class Foo {
    public int doSomething (int ...a) {
      int sum = 0;
      for (int i : a)
           sum += i;
        return sum;
    }
 }

Now you can call this function as :

doSomething (args)

For more information you can visit below link : http://www.geeksforgeeks.org/variable-arguments-varargs-in-java/

Answer 2

Unfortunately, you can't do this. The spread operator works in javascript because functions are allowed to accept two few (left out arguments are undefined) or too many arguments (extra arguments are ignored) of any type. Java, being strongly and statically typed, must always know exactly how many and what kind of arguments you are passing before you even compile the code.

You can probably find a hackaround with Java 8's functional interfaces, method references and var-args, but it would require so much boilerplate that I won't even bother posting it here.

Answer 3

If you need to call only few methods this way, you can do without Reflection simply by creating a wrapper class like this:

Main class (SpreadTest.java):

public class SpreadTest {
     public static void main(String []args){
        int[] a = {1, 2, 3};
        System.out.println(new FooWrapper().doSomething(a)); // 6
     } 
}

Your wrapper class (FooWrapper.java):

public class FooWrapper extends Foo {
    public int doSomething(int ...a) {
        return super.doSomething(a[0], a[1], a[2]);
    }
}

The class with the method which does the work (Foo.java):

public class Foo {
    public int doSomething(int a, int b, int c) {
        return a + b + c;
    }
}

Answer 4

Java language does not provide an operator to do this, but its class library has a facility to do what you need.

[from OP's comment] The developer of Foo could choose himself the number of arguments that function doSomething takes. I would then be able to construct a "bag" of arguments and inject it in the method.

Use reflection API, this is what it is for. It requires you to package arguments in an array. There is a lot of extra work required, including wrapping/unwrapping individual method arguments, and method result, but you can check the signature at run-time, construct an array, and call the method.

class Test {
    public static int doSomething(int a, int b, int c) {
        return a + b + c;
    }
    // This variable holds method reference to doSomething
    private static Method doSomethingMethod;
    // We initialize this variable in a static initialization block
    static {
        try {
            doSomethingMethod = Test.class.getMethod("doSomething", Integer.TYPE, Integer.TYPE, Integer.TYPE);
        } catch (Exception e) {
        }
    }
    public static void main (String[] ignore) throws java.lang.Exception {
        // Note that args is Object[], not int[]
        Object[] args = new Object[] {1, 2, 3};
        // Result is also Object, not int
        Object res = doSomethingMethod.invoke(null, args);
        System.out.println(res);
    }
}

The above code prints 6 (demo).

Answer 5

Actually, because for compatibility reasons, the signature of a method, which is using varargs function(Object... args) is the equivalent of a method declared with an array function(Object[] args).

Therefore in order to pass and spread any collection to function which expects varargs, you need to transform it to the array:

import java.util.Arrays;
import java.util.stream.Stream;

public class MyClass {
  
  static void printMany(String ...elements) {
     Arrays.stream(elements).forEach(System.out::println);
  }
  
  public static void main(String[] args) {
    printMany("one", "two", "three");
    printMany(new String[]{"one", "two", "three"});
    printMany(Stream.of("one", "two", "three").toArray(String[]::new));
    printMany(Arrays.asList("foo", "bar", "baz").toArray(new String[3]));
  }
}

All these calls of printMany will print:

one

two

three

It's not exactly the same as spread operator, but in most cases, it's good enough.

Answer 6

Contrary to numerous comments, e.g. by @JoeC and @Henry, and incorrect answers, this is possible in Java.

I'd like to use something like

doSomething (...args)

instead of calling doSomething(args[0], args[1], args[2]).

You need:

public int doSomething (int ... args) {
    int sum = 0;
    for (int i : args)
    {
        sum += i;
    }
    return sum;
}

I'd like not to change the implementation of such a function.

Impossible, a priori. Either you are adding exactly three arguments, or as many arguments as were actually passed. Make up your mind about this.