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];

function doSomething (a, b, c) {
    return a + b + c;
}

doSomething(...args);

As you can see, when calling doSomething, I am able to use the ... spread operator in order to "transform" my arguments into 1, 2, 3.

Now, I'm trying to do the same thing with Java.

Let's say I have a Foo class:

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

And now I want to call the doSomething:

int[] args = {1, 2, 3};

I'd like to use something like doSomething (...args) instead of calling doSomething(args[0], args[1], args[2]).

I saw that this is possible in the declaration of functions, but I'd like not to change the implementation of such a function.

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

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 3

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 4

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 5

You could do something like below

List<Integer> numbers = Arrays.asList(1, 2,3);
doSomething(numbers.toArray(Integer[]::new));

Answer 6

// A method that takes a variable number of integer arguments.
    static void fun(int ...a)
    {
        System.out.println("Number of arguments: " + a.length);
  
        // using for each loop to display contents of a
        for (int i: a)
            System.out.print(i + " ");
        System.out.println();
    }
  
    // Driver code
    public static void main(String args[])
    {
        // Calling the varargs method with different number
        // of parameters
        fun(100);         // one parameter
        fun(1, 2, 3, 4);  // four parameters
        fun();            // no parameter
    }

OUTPUT:

Number of arguments: 1
100 
Number of arguments: 4
1 2 3 4 
Number of arguments: 0

This is the most simple example for providing a Variable number of arguments in java. For JavaScript guyz this is also called as Rest Operator. But don't confuse with that if you know JS. To know more about this in Java please refer : [https://www.geeksforgeeks.org/variable-arguments-varargs-in-java/][1]

Answer 7

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 8

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.