Question

作业定义如下：

class Job<T> {
  String Class<T> type;

  T execute() throws Exception {
    return type.newInstance();
  }

  static <T> T execute(Job<T> aJob, Job<T>... jobs) {
    //... some lines of unrelated code...
    try{        
      return aJob.execute();
    } catch(Exception e){
      if(jobs.length == 0) throw new RuntimeException(e);
      return execute(jobs[0], Arrays.copyOfRange(jobs, 1, jobs.length));
    }
  }
}

重用try-catch块需要递归。如果一份工作失败了，我打电话给下一份工作。当没有任何作业成功时，我抛出一个RuntimeException包装实际的Exception。这仅仅是一种后备机制。代码与我的代码不同，但它具有相同的结构。

我的错误是执行的递归调用：

execute(jobs[0], Arrays.copyOfRange(jobs, 1, jobs.length));

我本可以使用Queue而不是数组：

T execute(Job<T> aJob, Queue<Job<T>> jobQueue) {  
//...
execute(jobQueue.poll(), jobQueue);
//...

我认为使用数组会产生更好的性能。但是使用队列可以使代码更具可读性和直观性。我没有测试过任何一个选项的性能。

什么样的数据结构可以提供更好的性能？
有没有更好的方法来进行这种递归调用？
使用for循环而不是递归会更好吗？

由于

Answer 1

在这种情况下，我认为你不想反复复制，因为你只在一个阵列上运行。

static <T> T execute(Job<T> aJob, int begin, Jobs[] jobs) {
    //... some lines of unrelated code...
    try{        
      return aJob.execute();
    } catch(Exception e){

      // if(jobs.length == 0) throw new RuntimeException(e);
      // The condition changed to begin < jobs.length

      if (begin == jobs.length) throws ... // End of array already

      return execute(jobs[0], begin + 1, jobs); // Advance to the next index. No need to copy the array
    }
}

我们只对单个阵列进行操作，无需复制。

递归通话效果

1 个答案: