Java 通过排列的循环的动态数量

我有一个程序可以动态访问不同的方法，每个方法都有不同数量的参数。我需要找到一种方法来排列这些参数的数千种不同排列，我不知道如何动态循环这些排列

例如，对于一个有两个参数的函数，我可以像这样迭代排列：

public static void main(String[] args) {
    List<Object[]> params = new ArrayList();
    params.add(new Integer[]{1,2,3});
    params.add(new Boolean[]{false,true});

    runCalculation("function1",params);
}

public void runCalculation(String functionName, List<Object> parameters){

    for(Object i : parameters.get(0)){
        for(Object j : parameters.get(1)){
            //Do reflection function call with (i,j) as parameters
        }
    }
}

publicstaticvoidmain（字符串[]args）{
List params=new ArrayList（）；
add（新整数[]{1,2,3}）；
add（新的布尔值[]{false，true}）；
运行计算（“功能1”，参数）；
}
public void runCalculation（字符串函数名，列表参数）{
对于（对象i:parameters.get（0））{
for（对象j:parameters.get（1））{
//使用（i，j）作为参数进行反射函数调用
}
}
}

但是，如果我要使用3个参数运行下一个函数，这将不再遍历所有排列。如何使用动态的for循环来正确处理包含参数值的数组列表？我认为递归是实现类似功能的唯一方法，但我仍在努力想出正确的解决方案，正确地允许每个函数使用动态数量的参数，然后为这些参数使用不同的类型。

public void runCalculation（String functionName，List…parameters）{
public void runCalculation(String functionName, List<Object> ... parameters){

    for(List<Object> list : parameters)
    {
         //Do reflection function call with obj as parameter
    }
}

用于（列表：参数）
{
//以obj为参数进行反射函数调用
}
}

---

它被称为，也可以尝试使用-它更易于使用，开销也很小

如果我不理解这个问题，很抱歉，但是嵌套for循环呢

for(int i = 0; i < params.size(); i++)
{
  for(int j = 0; j < params.get(i).size(); j++)
  {
  }
}

for（int i=0；i

这样行吗

编辑： 我知道了你在寻找什么算法，递归解决方案是：

public static String recursive(List<Object[]> params)
{
  String result = "";
  if(Params.isEmpty())
    return result;
  Object[] objects = params.remove(0);
  for(Object i : objects)
  {
    result += i.toString();
    List<Object[]> newParams = new ArrayList<>(newParams);
    result += recursive(newParams);
  }
  return result;
}

公共静态字符串递归（列表参数）
{
字符串结果=”；
if（Params.isEmpty（））
返回结果；
Object[]objects=params.remove（0）；
用于（对象i：对象）
{
结果+=i.toString（）；
List newParams=newarraylist（newParams）；
结果+=递归（新参数）；
}
返回结果；
}

我认为您在这里尝试的是反射。您只需要阅读API并使用适当的方法。请注意，需要知道要在哪个类上调用方法名。Java不会为您检查所有类中的所有方法

   public void runCalculation(String functionName, List<Object> parameters)
           throws NoSuchMethodException
   {
      Class<?>[] typeSignature = new Class<?>[ parameters.size() ];
      for( int i = 0; i < parameters.size(); i++ ) {
         typeSignature[i] = parameters.get( i ).getClass();
      }
      Class<?> type = this.getClass(); // substitute with desired class
      Method m = type.getMethod(functionName, typeSignature);
      // do stuff with 'm' here (like invoke it)

   }

public void runCalculation（字符串函数名，列表参数）
抛出NoSuchMethodException
{
Class[]typeSignature=新类[parameters.size（）]；
对于（int i=0；i

这是我的解决方案（我不知道数组没有实现

Iterable

，我现在懒得更改它，因为它是基于interator的）：

---

下面是如何在C中执行类似操作：应该很容易转换为Java

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

runCalculation( char * functionName, char * parameters, int numParams )
{
    int size = strlen(parameters);  // number of parameters to choose from
    int i, j;
    int indices[numParams];

    for (i=0; i < numParams; ++i)
        // initialise indices
        indices[i] = i;

    while (1) {
        // output parameters
        for (i=0; i < numParams; ++i)
            printf("%c", parameters[indices[i]]);
        printf("\n");

        // now advance j'th parameter
        j = numParams - 1;
        while(1) {
            indices[j]++;
            if (indices[j] < size - (numParams-1-j))
                // found a combination that 'works'
                break;
            // can't create a new combination with current j, so try new one
            --j;
            if (j < 0)
                return;
        }
        // reset everything after indices[j]: they will all be consecutive
        for (i=j+1; i < size; ++i)
            indices[i] = indices[i-1] + 1;

    }

}


main( int argc, char ** argv) {
    if (argc != 3) {
        printf("need two arguments (string to permute, # of combo elements): bye\n");
        exit(1);
    }
    runCalculation( "testFunction", argv[1], atoi(argv[2]) );

}

---

将代码保存到您的系统中，编译它，尝试各种测试用例，一旦您确信这就是您所需要的，然后向我展示编写此代码的Java方法。让我知道。谢谢。

也许你需要递归而不是for循环？你需要的不是

置换

，而是

笛卡尔积

或

n元积

（我将很快添加答案）这解决不了任何问题。。。我已经非常了解反思，并在原始问题中提到了反思。这甚至不起作用，因为parameters中的每个对象都是一个参数数组，而不是传递给函数所需的数组中的单个项。你完全误解了这个问题。这根本没有任何意义——我认为你需要回到基础上来，从头开始学习java。但是你在一个方面是对的，尽管你甚至都不知道：我在循环中有一个拼写错误，现在已经纠正了。你就是那个误解这个问题的人。此后，我通过使用递归调用实现笛卡尔积函数解决了这个问题。它接受任意数量的对象参数，并在列表中返回笛卡尔积，结果是{1,2,3}，{false，true}的输入参数输出{1，false}{1，true}{2，false}等。在因为你不理解某件事而告诉某人“回到基础上来”之前，也许重新阅读这个问题，看看你困惑的答案是否一直存在。

one, 3, true
one, 3, false
one, 4, true
one, 4, false
two, 3, true
two, 3, false
two, 4, true
two, 4, false

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

runCalculation( char * functionName, char * parameters, int numParams )
{
    int size = strlen(parameters);  // number of parameters to choose from
    int i, j;
    int indices[numParams];

    for (i=0; i < numParams; ++i)
        // initialise indices
        indices[i] = i;

    while (1) {
        // output parameters
        for (i=0; i < numParams; ++i)
            printf("%c", parameters[indices[i]]);
        printf("\n");

        // now advance j'th parameter
        j = numParams - 1;
        while(1) {
            indices[j]++;
            if (indices[j] < size - (numParams-1-j))
                // found a combination that 'works'
                break;
            // can't create a new combination with current j, so try new one
            --j;
            if (j < 0)
                return;
        }
        // reset everything after indices[j]: they will all be consecutive
        for (i=j+1; i < size; ++i)
            indices[i] = indices[i-1] + 1;

    }

}


main( int argc, char ** argv) {
    if (argc != 3) {
        printf("need two arguments (string to permute, # of combo elements): bye\n");
        exit(1);
    }
    runCalculation( "testFunction", argv[1], atoi(argv[2]) );

}

abcd
abce
abcf
abde
abdf
abef
acde
acdf
acef
adef
bcde
bcdf
bcef
bdef
cdef