Varargs in a group?

Question

About Varargs, can i repeat the arguments in a group?

For instance, i want to allow users pass in:

myFunc(1, "one");
myFunc(1, "one", 2, "two");
myFunc(1, "one", 2, "two", 3, "three");

It seems impossible. But as mentioned in the docs, the varargs is in fact an array, in old implementation. i would like to know how was people do before varargs is invented. That might inspire us how to achieve the above scenario. We can regard my scenario as {int, String}... repeating afterall.

Thanks for any input :-)

Edit:

Thanks for all your inputs!

So, is it calling by myFunc(new wrap(1, "one"), new wrap(2, "two"), new wrap(3, "three")); is the old method?

Edit 2:

Well, nope. Thats my fault of confusion.

For

myFunc(1);
myFunc(1, 2);
myFunc(1, 2, 3);

the old way should be

myFunc(new int[]{1});
myFunc(new int[]{1, 2});
myFunc(new int[]{1, 2, 3});

As far as i can see, as the repeating arguments form an array. All its arguments has to be of the same type. It should be impossible to achieve the above calls in a simple way. For curiosity, i start thinking of the possibility of operator overloading ... (?)

Answer 1

In this case, it seems to me that it's suitable to create a datastructure for your "pair", and then use that type as vararg argument to your method.

public void myFunc(Pair... pairs) {}

You could also use Object..., but I don't see any advantages in this case, since the arguments always come in pairs.

Answer 2

There are good reasons to use the other solutions, but they all introduce a bit of clutter (to create all those objects) you might not want to subject the users of your library to.

You can shift the clutter to the inside of your method like so:

public void example(final Object... args) {
    if (args.length % 2 != 0)
        throw new IllegalArgumentException("int, String pairs are required, but there seems to be an odd one out");

    for (int i = 0; i < args.length; i += 2) {
        int a = (Integer) args[i];
        String b = (String) args[i + 1];

        System.out.printf("%d: %s\n", a, b);
    }
}

example(1, "Hello", 2, "Goodbye", 25, "Raptors will eat you!"); will then produce the following output:

1: Hello
2: Goodbye
25: Raptors will eat you!

Answer 3

What about creating a wrapper class that wraps the two parameters together?

public class TwoParameter
{
    private int intValue;
    private String stringValue;

    public TwoParameter(int intValue, String stringValue)
    {
        this.intValue = intValue;
        this.stringValue = stringValue;
    }

    // getters and setters
}

and then use it like:

myFunc(new TwoParameter(1, "one"), new TwoParameter(2, "two"));

The signature of the method would be something like this:

public void myFunc(TwoParameter... params){...}

Answer 4

Var args were introduced to allow you to send an arbitrary number of arguments to a function. Folks hacked around with other Collections / arrays before they came about.

You can achieve what you want with a custom structure. The particulars of the structure will depend on what the name value pair should achieve. Here is a generic solution for any NameValue pair.

NameValuePair

class NameValuePair<K,V>
{
    private K key;
    private V value;
    public K getKey()
    {
        return key;
    }
    public void setKey(K key)
    {
        this.key = key;
    }
    public V getValue()
    {
        return value;
    }
    public void setValue(V value)
    {
        this.value = value;
    }
}

Usage

private <K,V> void method(NameValuePair<K, V>... pairs )
{
    for (NameValuePair<K, V> nameValuePair : pairs)
    {
        K key = nameValuePair.getKey();
        V value = nameValuePair.getValue();
        // logic goes here 
    }
}