Java 如何使用不同的组合调用函数

我有三个用java编写的函数

test1（）

，

test2（）

和

test3（）

。我想写一段代码，迭代并将它们调用到所有不同的组合中

例如

• 第一次迭代执行

  test1（）

  ，然后执行

  test2（）

  ，最后执行

  test3（）

• 第二次迭代执行

  test2（）

  ，

  test1（）

  ，最后执行

  test3（）

  e.t.c

---

有没有一种可能的方法可以通过迭代器实现这一点，或者我必须手动实现这一点？

您可以使用反射来获取一个方法数组，然后遍历每个列表，并一次调用一个方法。请看下面的图片。下面是一个简单的例子：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class SO {
  public void test1() {
        System.out.println("Running test1");
  }
  public void test2() {
        System.out.println("Running test2");
  }
  public void test3() {
        System.out.println("Running test3");
  }
  public void notATest() {
        System.err.println("THIS IS NOT A TEST");
  }

  public static void main(String ... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    Class c = SO.class;
    SO that = new SO();
    Method[] methods = filter(c.getDeclaredMethods(), "test");
    PermuteMethod permutations = new PermuteMethod(methods);
    while(permutations.hasNext()) {
      for(Method permutation: permutations.next()) {
        permutation.invoke(that, null);
      }
      System.out.println("----");
    }
  }
  private static Method[] filter(Method[] declaredMethods, String startsWith) {
    List<Method> filtered = new ArrayList<>();
    for(Method method : declaredMethods) {
      if(method.getName().startsWith(startsWith)) {
        filtered.add(method);
      }
    }
    return filtered.toArray(new Method[filtered.size()]);
  }
}

这是使用以下（修改）版本的：

import java.lang.reflect.Array；
导入java.lang.reflect.Method；
导入java.util.Iterator；
导入java.util.NoSuchElementException；
公共类PermuteMethod实现迭代器{
私人最终整数大小；
私有final方法[]元素；//原始0的副本..大小为1
私有final方法[]ar；//输出数组，0..size-1
private final int[]permutation；//nums的perm 1..size，perm[0]=0
private boolean next=true；
公共置换法（方法[]e）{
尺寸=e.长度；
元素=新方法[大小]；
数组副本（e，0，元素，0，大小）；
ar=新方法[尺寸]；
系统阵列副本（e，0，ar，0，大小）；
排列=新整数[大小+1]；
对于（int i=0；i置换[i+1]）
我--；
如果（i==0）{
下一个=假；
对于（int j=0；j置换[j]）
j--；
互换（i，j）；
int r=大小；
int s=i+1；
while（r>s）{
互换（r，s）；
r--；
s++；
}
返回ar；
}
}

要获得所有排列，您可以使用

番石榴

项目。请看这节课

---

然后使用内省调用对象上的方法。

可以使用嵌套循环来实现它。

---

在最内部的循环中，基于循环计数器值的调用

是否尝试对其进行编码？创建一个包含三个元素的数组-

{1，2，3}

。写一个算法来产生这些元素的排列。对于每个排列，遍历结果数组。如果在索引0处找到

1

，请调用

test1

，如果找到

2

，请调用

test2

，依此类推。。。。。。。这可能会有一些用处。我认为您不想对列表进行洗牌。你需要遍历排列。思想是通过填充你可以很容易地保证每个方法被调用一次，并且所有方法都被调用。在这种情况下，不需要使用反射，一个简单的数组就足够了。而且，洗牌可能不会产生所有的组合。最后，我明白了排列是一种更好的方法。更新了我的答案，添加了一个链接，作为对OPAs的评论，用于反射。确实，您不需要它，但通过反射，可以创建一个处理所有置换的通用测试函数，并且不需要在每次引入新方法时进行更新。

Running test1
Running test2
Running test3
----
Running test1
Running test3
Running test2
----
Running test2
Running test1
Running test3
----
Running test2
Running test3
Running test1
----
Running test3
Running test1
Running test2
----
Running test3
Running test2
Running test1
----

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class PermuteMethod implements Iterator<Method[]> {
  private final int size;
  private final Method[] elements; // copy of original 0 .. size-1
  private final Method[] ar; // array for output, 0 .. size-1
  private final int[] permutation; // perm of nums 1..size, perm[0]=0

  private boolean next = true;

  public PermuteMethod(Method[] e) {
    size = e.length;
    elements = new Method[size];
    System.arraycopy(e, 0, elements, 0, size);
    ar = new Method[size];
    System.arraycopy(e, 0, ar, 0, size);
    permutation = new int[size + 1];
    for (int i = 0; i < size + 1; i++) {
      permutation[i] = i;
    }
  }

  private void formNextPermutation() {
    for (int i = 0; i < size; i++) {
      Array.set(ar, i, elements[permutation[i + 1] - 1]);
    }
  }

  public boolean hasNext() {
    return next;
  }

  public void remove() throws UnsupportedOperationException {
    throw new UnsupportedOperationException();
  }

  private void swap(final int i, final int j) {
    final int x = permutation[i];
    permutation[i] = permutation[j];
    permutation[j] = x;
  }

  public Method[] next() throws NoSuchElementException {
    formNextPermutation(); // copy original elements
    int i = size - 1;
    while (permutation[i] > permutation[i + 1])
      i--;
    if (i == 0) {
      next = false;
      for (int j = 0; j < size + 1; j++) {
        permutation[j] = j;
      }
      return ar;
    }
    int j = size;
    while (permutation[i] > permutation[j])
      j--;
    swap(i, j);
    int r = size;
    int s = i + 1;
    while (r > s) {
      swap(r, s);
      r--;
      s++;
    }
    return ar;
  }
}