Java：重构嵌套循环

我目前正在实现一个基于数学公式构造矩阵模式的算法。为了实现这一点，我使用了深度嵌套的for循环和许多if条件。问题是，如果不提供大量参数，我无法将循环拆分为多个方法。现在这个代码看起来像是一个不受欢迎的意大利面代码

下面是一个小的伪示例：

int steps = 10;

void evaluate( int numOuterArea , int numInnerArea , int[] solution , int[] factor , int[] indices )
{
  int counterA = 0;
  int counterB = 0;

  for( int outerAreaIter = 0 ; outerAreaIter < numOuterArea ; outerAreaIter++ )
  {
    for( int curOuterAreaIter = 0 ; curOuterAreaIter < steps ; curOuterAreaIter++ )
    {
      for( int innerAreaIter = 0 ; innerAreaIter < numInnerArea ; innerAreaIter++ )
      {
        for( int curInnerAreaIter = 0 ; curInnerAreaIter < curOuterAreaIter ; curInnerAreaIter++ )
        {
          if( curInnerAreaIter == curOuterAreaIter )
          {
            // do something with solution, factor or indices
          }
          else if( /* some other fancy condition */)
          {

          }
          ...
        }
      }
    }
  }

  // similar nested loops follow here
}

int步数=10；
无效评估（int numOuterArea、int numInnerArea、int[]解决方案、int[]因子、int[]指数）
{
int计数器A=0；
int计数器b=0；
for（int-outerAreaIter=0；outerAreaIter

如果我要为每个循环或循环的一部分编写类/方法，我必须提供

evaluate（）

（如示例所示，可能更多）中的所有参数，以及所有以前的迭代器和可能的变量

---

有没有一种方法/常规做法/任何提示或建议来以更好的方式重写此类代码？

简单的设计模式是一种选择。只需编写一个负责此计算的类。然后，您可以拥有一些字段，这些字段只存储计算期间的中间结果。使用这种方法，您不需要传递任何参数

例如：

class EvaluateMethod {
    private final int numOuterArea;
    private final int numInnerArea;
    private final int[] solution;
    private final int[] factor;
    private final int[] indices;

    // place fields for intermediate results here

    EvaluateMethod(int numOuterArea, int numInnerArea, int[] solution, int[] factor, int[] indices) {
        // assign all parameter to fields here
    }

    void execute() {
        // Your method body as before comes here.
        // But you can extract methods easily.
    }
}

---

另一个注意事项：不能重用此类的实例。我称它们为一次性对象，必须实例化、使用和丢弃。

最简单的方法是将所有参数封装在单个对象中。您可以使用此对象将数据作为唯一参数传递给求值方法。类似于此示例：

class EvaluationContext {
    int numOuterArea;
    int numInnerArea;
    int[] solution;
    int[] factor;
    int[] indices;
}

interface Evaluator {
    void evaluate(EvaluationContext ctx); 
}

class FirstEvaluator implements Evaluator {
    void evaluate(EvaluationContext ctx) {
        SecondEvaluator e2 = new SecondEvaluator(); 
        for (...) {
            e2.evaluate(ctx);
        }
    }
}

class SecondEvaluator implements Evaluator {
    void evaluate(EvaluationContext ctx) {
        // evaluate something and put result into context
    }
}

---

@布尼环本身总是一样的吗？只有最内部for循环的代码块发生了变化？否，循环在不同的

evaluate（）

函数中发生了多次变化，并且在函数内部有几种不同的实现。而且条件、变量等每次都会发生变化。