Java преобразовать массив в параметры

Question

Есть ли способ преобразовать массив в список параметров ..?

main(){
   //"a" is an array or a list or some collection
   myPrint(a.SomeMethod);
}

void myPrint(int a){
//Do Stuff to arguments
}

void myPrint(int a, int b){
//Do Stuff to arguments
}

void myPrint(int a, int b, int c){
//Do Stuff to arguments
}

Я хочу преобразовать «a» в список параметров / аргументов, чтобы он автоматически вызывал соответствующую функцию.

Answer 1

main(){
   int[] a = {1,2,3};
   MyPrint(a);
}

void MyPrint(int... x){
//Do Stuff to arguments (accessing them by its index)
}

Answer 2

Было бы крайне странно делать то, что вы пытаетесь сделать.Если вы ищете универсальный способ сделать это, вам нужно погрузиться в рефлексию (java.lang.reflect).Если у вас действительно есть массив / коллекция с 1, 2 или 3 целыми числами и вы хотите вызвать другой метод, основанный на этом, то просто напишите метод, который вычисляет число значений в «вещи» и вызывает соответствующий метод.

Можете ли вы сказать нам, почему вы хотите это сделать?

Редактировать:

Код для жестко закодированного способа:

public class Main
{
    public static void main(String[] args)
    {
        final Main main;

        main = new Main();
        main.callFoo(new int[] {1});
        main.callFoo(new int[] {1, 2});
        main.callFoo(new int[] {1, 2, 3});
    }

    private void callFoo(final int[] values)
    {
        if(values.length == 1)
        {
            foo(values[0]);
        }
        else if(values.length == 2)
        {
            foo(values[0], values[1]);
        }
        else if(values.length == 3)
        {
            foo(values[0], values[1], values[2]);
        }
        else
        {
            throw new Error("too many values: " + values.length);
        }
    }

    private void foo(int a)
    {
        System.out.println("foo(" + a + ")");
    }

    private void foo(int a, int b)
    {
        System.out.println("foo(" + a + ", " + b + ")");
    }

    private void foo(int a, int b, int c)
    {
        System.out.println("foo(" + a + ", " + b + ", " + c + ")");
    }
}

Вот отражениеверсия (я не буду обрабатывать ошибки через printStackTrace, но это отправная точка):

public class Main
{
    public static void main(String[] args)
    {
        final Main main;

        main = new Main();
        main.callFoo(new int[] {1});
        main.callFoo(new int[] {1, 2});
        main.callFoo(new int[] {1, 2, 3});
    }

    private void callFoo(final int[] values)
    {
        final Class[] parameters;

        parameters = new Class[values.length];

        for(int i = 0; i < parameters.length; i++)
        {
            parameters[i] = int.class;
        }

        try
        {
            final Method   method;
            final Object[] args;

            method = Main.class.getDeclaredMethod("foo", parameters);
            args   = new Object[values.length];

            for(int i = 0; i < args.length; i++)
            {
                args[i] = Integer.valueOf(values[i]);
            }

            method.invoke(this, args);
        }
        catch(final IllegalAccessException ex)
        {
            ex.printStackTrace();
        }
        catch(final IllegalArgumentException ex)
        {
            ex.printStackTrace();
        }
        catch(final InvocationTargetException ex)
        {
            ex.printStackTrace();
        }
        catch(final NoSuchMethodException ex)
        {
            ex.printStackTrace();
        }
        catch(final SecurityException ex)
        {
            ex.printStackTrace();
        }
    }

    private void foo(int a)
    {
        System.out.println("foo(" + a + ")");
    }

    private void foo(int a, int b)
    {
        System.out.println("foo(" + a + ", " + b + ")");
    }

    private void foo(int a, int b, int c)
    {
        System.out.println("foo(" + a + ", " + b + ", " + c + ")");
    }
}

Изменить ... последний - этот будет работать для любого метода (вы передаете ему имяметод).Это наименее безопасный вариант - опечатка в названии может испортить вам день: -)

public class Main
{
    public static void main(String[] args)
    {
        final Main main;

        main = new Main();
        main.call("foo", new int[] {1});
        main.call("foo", new int[] {1, 2});
        main.call("foo", new int[] {1, 2, 3});
        main.call("bar", new int[] {1});
        main.call("bar", new int[] {1, 2});
        main.call("bar", new int[] {1, 2, 3});
    }

    private void call(final String methodName, 
                      final int[]  values)
    {
        final Class[] parameters;

        parameters = new Class[values.length];

        for(int i = 0; i < parameters.length; i++)
        {
            parameters[i] = int.class;
        }

        try
        {
            final Method   method;
            final Object[] args;

            method = Main.class.getDeclaredMethod(methodName, parameters);
            args   = new Object[values.length];

            for(int i = 0; i < args.length; i++)
            {
                args[i] = Integer.valueOf(values[i]);
            }

            method.invoke(this, args);
        }
        catch(final IllegalAccessException ex)
        {
            ex.printStackTrace();
        }
        catch(final IllegalArgumentException ex)
        {
            ex.printStackTrace();
        }
        catch(final InvocationTargetException ex)
        {
            ex.printStackTrace();
        }
        catch(final NoSuchMethodException ex)
        {
            ex.printStackTrace();
        }
        catch(final SecurityException ex)
        {
            ex.printStackTrace();
        }
    }

    private void foo(int a)
    {
        System.out.println("foo(" + a + ")");
    }

    private void foo(int a, int b)
    {
        System.out.println("foo(" + a + ", " + b + ")");
    }

    private void foo(int a, int b, int c)
    {
        System.out.println("foo(" + a + ", " + b + ", " + c + ")");
    }

    private void bar(int a)
    {
        System.out.println("bar(" + a + ")");
    }

    private void bar(int a, int b)
    {
        System.out.println("bar(" + a + ", " + b + ")");
    }

    private void bar(int a, int b, int c)
    {
        System.out.println("bar(" + a + ", " + b + ", " + c + ")");
    }
}

Answer 3

Короче говоря, это действительно невозможно. Единственный способ получить переменное число аргументов - это конструкция int...x. В противном случае вам нужно выяснить, сколько элементов содержится в a, а затем выяснить, какой из них вызвать.

if (a.length == 2) {
    MyPrint(a[0], a[1]);
}
else if (a.length == 3) {
    MyPrint(a[0], a[1], a[2]);
}
// etc